cdata (clj)

(ns ^{:doc "Tests for reading [:tag {:attr 'value} body*] as XML."
      :author "Alan Malloy"}
  clojure.data.xml.test-sexp
  (:require
   [clojure.test :refer :all]
   [clojure.data.xml :refer :all]
   [clojure.data.xml.test-utils :refer (test-stream lazy-parse*)]))

(deftest with-cdata
  (let [xml-input (element :tag {:attr "value"}
                           (element :body {} (cdata "not parsed <stuff")))
        sexp-input [:tag {:attr "value"} [:body {} [:-cdata "not parsed <stuff"]]]]
    (is (= xml-input
           (sexp-as-element sexp-input)))))

(deftest with-multiple-cdata
  (testing "separate cdata"
    (let [xml-input (element :tag {:attr "value"}
                             (element :body {}
                                      (cdata "not parsed <stuff")
                                      (cdata "more not parsed <stuff")))
          sexp-input [:tag {:attr "value"} [:body {}
                                            (list [:-cdata "not parsed <stuff"]
                                                  [:-cdata "more not parsed <stuff"])]]]
      (is (= xml-input
             (sexp-as-element sexp-input)))))
  (testing "cdata with embedded ]]>"
    (let [xml-input (element :tag {:attr "value"}
                             (element :body {}
                                      (cdata "not parsed <stuff]]")
                                      (cdata ">more not parsed <stuff")))
          sexp-input [:tag {:attr "value"}
                      [:body {}
                       [:-cdata "not parsed <stuff]]>more not parsed <stuff"]]]]
      (is (= (emit-str xml-input)
             (emit-str (sexp-as-element sexp-input)))))))

(ns ^{:doc "Tests for XML parsing functions."
      :author "Chris Houser"}
  clojure.data.xml.test-parse
  (:require
   [clojure.test :refer :all]
   [clojure.data.xml :refer [parse-str element]]
   [clojure.data.xml.test-utils :refer [test-stream lazy-parse*]]))

(deftest test-cdata-parse
(let [input "<cdata><is><here><![CDATA[<dont><parse><me>]]></here></is></cdata>"
      expected (element :cdata {} (element :is {}
                                           (element :here {}
                                                    "<dont><parse><me>")))]
  (is (= expected (lazy-parse* input)))))

(ns clojure.data.xml.test-cljs-basic
  (:require
   [cljs.test :as test :refer [deftest is are]]
   [clojure.data.xml :as xml :refer [parse-str emit-str element element-data element-node]]
   [clojure.data.xml.node :as node]
   [clojure.data.xml.js.dom :as dom]))

(deftest roundtrips
  (are [dxml xml] (do (is (= dxml (xml/parse-str xml)))
                      (is (= dxml (xml/parse-str (xml/emit-str dxml)))))
    (xml/element :foo) "<foo/>"
    (xml/element :xmlns.DAV%3A/foo) "<foo xmlns=\"DAV:\"/>"
    (xml/element :foo {} (xml/cdata "<foo")) "<foo><![CDATA[<foo]]></foo>"
    (xml/element :foo {} (xml/xml-comment " bar> ")) "<foo><!-- bar> --></foo>"))