public void TestWriteXml()
        {
            SimpleDocument sd = new SimpleDocument("root");

            sd.Encoding        = "UTF-8";
            sd.DocumentComment = "document comment";

            TextWriter writer = new StringWriter();

            sd.WriteXml(writer, true);
            Assert.AreEqual(sd.ToString(), writer.ToString());
            Assert.IsTrue(writer.ToString().IndexOf("\n") >= 0);
            writer = new StringWriter();
            sd.WriteXml(writer, false);
            Assert.IsFalse(writer.ToString().IndexOf("\n") >= 0);

            sd.DtdUri = "dtd.uri";
            writer    = new StringWriter();
            sd.WriteXml(writer, false);
            string result = writer.ToString();

            Assert.IsFalse(result.IndexOf("\n") >= 0);
            Assert.IsTrue(result.IndexOf("SYSTEM") >= 0);

            sd.DtdName = "dtdname";
            writer     = new StringWriter();
            sd.WriteXml(writer, true);
            result = writer.ToString();
            Assert.IsTrue(result.IndexOf("\n") >= 0);
            Assert.IsTrue(result.IndexOf("PUBLIC") >= 0);
        }
        public void TestObjectMethods()
        {
            SimpleDocument sd1 = new SimpleDocument("doc1");
            SimpleDocument sd2 = new SimpleDocument("doc2");

            Assert.IsFalse(sd1.Equals(sd2));
            sd1.Name = "doc2";
            Assert.IsTrue(sd1.Equals(sd2));
            sd1.DocumentComment = "comment";
            Assert.IsFalse(sd1.Equals(sd2));
            sd2.DocumentComment = sd1.DocumentComment;
            Assert.IsTrue(sd1.Equals(sd2));
            sd1.DtdUri = "test.dtd";
            Assert.IsFalse(sd1.Equals(sd2));
            Assert.AreNotEqual(sd1.GetHashCode(), sd2.GetHashCode());
            sd2.DtdUri = sd1.DtdUri;
            Assert.IsTrue(sd1.Equals(sd2));
            sd1.DtdName = "public name";
            Assert.IsFalse(sd1.Equals(sd2));
            sd2.DtdName = sd1.DtdName;
            Assert.IsTrue(sd1.Equals(sd2));
            sd1.Encoding = "UTF-8";
            Assert.IsFalse(sd1.Equals(sd2));
            sd2.Encoding = sd1.Encoding;
            Assert.IsTrue(sd1.Equals(sd2));
            Assert.AreEqual(sd1.GetHashCode(), sd2.GetHashCode());

            SimpleElement se = new SimpleElement();

            Assert.IsFalse(sd1.Equals(se));
        }
        public void TestTransformInitParams()
        {
            IXmlDocument root       = new SimpleDocument("root");
            IXmlDocument initParams = new SimpleDocument("init-params");

            for (int i = 1; i < 4; i++)
            {
                IXmlElement paramEl = initParams.AddElement("init-param");
                paramEl.AddElement("param-name").SetString("name" + i);
                paramEl.AddElement("param-value").SetInt(i);
            }
            Assert.AreEqual(initParams.ElementList.Count, 3);
            Assert.AreEqual(root.ElementList.Count, 0);
            XmlHelper.TransformInitParams(root, initParams);
            Assert.AreEqual(root.ElementList.Count, 3);
            for (int i = 1; i < 4; i++)
            {
                Assert.IsNotNull(root.GetElement("name" + i));
                Assert.AreEqual(root.GetElement("name" + i).GetInt(), i);
            }

            IXmlDocument xml = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-test-util-transformparams.xml");

            IXmlElement el = xml.FindElement("configurable-cache-factory-config/init-params");

            root = new SimpleDocument("root");
            XmlHelper.TransformInitParams(root, el);
            Assert.IsNotNull(root.GetElement("long"));
            Assert.IsNotNull(root.GetElement("date"));
            Assert.IsNotNull(root.GetElement("float"));
        }
        public void TestConstructors()
        {
            SimpleDocument sd = new SimpleDocument("doc");

            Assert.IsNotNull(sd);
            Assert.AreEqual(sd.Name, "doc");

            sd = new SimpleDocument("doc", "test.dtd", null);
            Assert.IsNotNull(sd);
            Assert.IsNotNull(sd.Name);
            Assert.IsNotNull(sd.DtdUri);
            Assert.IsNull(sd.DtdName);
        }
        public void TestSerialization()
        {
            ConfigurablePofContext ctx = new ConfigurablePofContext("assembly://Coherence.Tests/Tangosol.Resources/s4hc-test-config.xml");

            Assert.IsNotNull(ctx);

            SimpleDocument sd = new SimpleDocument();

            sd.Name            = "doc";
            sd.DtdUri          = "test.dtd";
            sd.DtdName         = "public name";
            sd.Encoding        = "UTF-8";
            sd.DocumentComment = "comment";

            Stream stream = new MemoryStream();

            ctx.Serialize(new DataWriter(stream), sd);

            stream.Position = 0;
            SimpleDocument sdd = (SimpleDocument)ctx.Deserialize(new DataReader(stream));

            Assert.AreEqual(sd, sdd);
        }
        public void TestProperties()
        {
            SimpleDocument sd = new SimpleDocument();
            Exception      e  = null;

            sd.Name = "doc";
            Assert.IsNotNull(sd.Name);

            sd.DtdUri = "test.dtd";
            Assert.IsNotNull(sd.DtdUri);

            sd.DtdName = null;
            Assert.IsNull(sd.DtdName);
            sd.DtdName = "";
            Assert.IsNull(sd.DtdName);
            try
            {
                sd.DtdName = "\"test";
            }
            catch (Exception ex)
            {
                e = ex;
            }
            Assert.IsNotNull(e);
            Assert.IsInstanceOf(typeof(ArgumentException), e);
            sd.DtdName = "public name";
            Assert.IsNotNull(sd.DtdName);

            sd.Encoding = "";
            Assert.IsNull(sd.Encoding);
            sd.Encoding = "UTF-8";
            Assert.IsNotNull(sd.Encoding);
            e = null;
            try
            {
                sd.Encoding = "?test";
            }
            catch (Exception ex)
            {
                e = ex;
            }
            Assert.IsNotNull(e);
            Assert.IsInstanceOf(typeof(ArgumentException), e);

            sd.DocumentComment = "";
            Assert.IsNull(sd.DocumentComment);
            sd.DocumentComment = "comment";
            Assert.IsNotNull(sd.DocumentComment);
            e = null;
            try
            {
                sd.DocumentComment = "c-->";
            }
            catch (Exception ex)
            {
                e = ex;
            }
            Assert.IsNotNull(e);
            Assert.IsInstanceOf(typeof(ArgumentException), e);

            sd.IsMutable = false;
            e            = null;
            try
            {
                sd.DocumentComment = "comm";
            }
            catch (Exception ex)
            {
                e = ex;
            }
            Assert.IsNotNull(e);
            Assert.IsInstanceOf(typeof(InvalidOperationException), e);
        }