From 54df2afaa61c6a03cbb4a33c9b90fa572b6d07b8 Mon Sep 17 00:00:00 2001 From: Jesse Morgan Date: Sat, 17 Dec 2016 21:28:53 -0800 Subject: Berkeley DB 4.8 with rust build script for linux. --- db-4.8.30/test/scr037/Configuration.cs | 1107 ++++++++++++++++++++++++++++++++ 1 file changed, 1107 insertions(+) create mode 100644 db-4.8.30/test/scr037/Configuration.cs (limited to 'db-4.8.30/test/scr037/Configuration.cs') diff --git a/db-4.8.30/test/scr037/Configuration.cs b/db-4.8.30/test/scr037/Configuration.cs new file mode 100644 index 0000000..abf0079 --- /dev/null +++ b/db-4.8.30/test/scr037/Configuration.cs @@ -0,0 +1,1107 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2009 Oracle. All rights reserved. + * + */ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Xml; +using BerkeleyDB; +using NUnit.Framework; + +namespace CsharpAPITest +{ + public class Configuration + { + /* + * Configure the value with data in xml and return true or + * false to indicate if the value is configured. If there + * is no testing data and it is optional, return false. If + * there is no testing data in xml and it is compulsory, + * ConfigNotFoundException will be thrown. If any testing + * data is provided, the value will be set by the testing + * data and true will be returned. + */ + #region Config + public static void ConfigAckPolicy(XmlElement xmlElem, + string name, ref AckPolicy ackPolicy, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, + name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + string policy = xmlNode.InnerText; + if (policy == "ALL") + ackPolicy = AckPolicy.ALL; + else if (policy == "ALL_PEERS") + ackPolicy = AckPolicy.ALL_PEERS; + else if (policy == "NONE") + ackPolicy = AckPolicy.NONE; + else if (policy == "ONE") + ackPolicy = AckPolicy.ONE; + else if (policy == "ONE_PEER") + ackPolicy = AckPolicy.ONE_PEER; + else if (policy == "QUORUM") + ackPolicy = AckPolicy.QUORUM; + else + throw new InvalidConfigException(name); + } + } + + public static bool ConfigBool(XmlElement xmlElem, + string name, ref bool value, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + value = bool.Parse(xmlNode.InnerText); + return true; + } + + public static bool ConfigByteOrder(XmlElement xmlElem, + string name, ref ByteOrder byteOrder, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + byteOrder = ByteOrder.FromConst( + int.Parse(xmlNode.InnerText)); + return true; + } + + public static bool ConfigByteMatrix(XmlElement xmlElem, + string name, ref byte[,] byteMatrix, bool compulsory) + { + int i, j, matrixLen; + + XmlNode xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + matrixLen = xmlNode.ChildNodes.Count; + byte[,] matrix = new byte[matrixLen, matrixLen]; + for (i = 0; i < matrixLen; i++) + { + if (xmlNode.ChildNodes[i].ChildNodes.Count != matrixLen) + throw new ConfigNotFoundException(name); + for (j = 0; j < matrixLen; j++) + { + matrix[i, j] = byte.Parse( + xmlNode.ChildNodes[i].ChildNodes[j].InnerText); + } + } + + byteMatrix = matrix; + return true; + } + + public static bool ConfigCacheInfo(XmlElement xmlElem, + string name, ref CacheInfo cacheSize, bool compulsory) + { + XmlNode xmlNode; + XmlNode xmlChildNode; + uint bytes; + uint gigabytes; + int nCaches; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "Bytes")) != null) + { + bytes = uint.Parse(xmlChildNode.InnerText); + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "Gigabytes")) != null) + { + gigabytes = uint.Parse(xmlChildNode.InnerText); + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "NCaches")) != null) + { + nCaches = int.Parse(xmlChildNode.InnerText); + cacheSize = new CacheInfo(gigabytes,bytes,nCaches); + return true; + } + } + } + } + + return false; + } + + public static bool ConfigCachePriority(XmlElement xmlElem, + string name, ref CachePriority cachePriority, bool compulsory) + { + XmlNode xmlNode; + string priority; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + priority = xmlNode.InnerText; + if (priority == "DEFAULT") + cachePriority = CachePriority.DEFAULT; + else if (priority == "HIGH") + cachePriority = CachePriority.HIGH; + else if (priority == "LOW") + cachePriority = CachePriority.LOW; + else if (priority == "VERY_HIGH") + cachePriority = CachePriority.VERY_HIGH; + else if (priority == "VERY_LOW") + cachePriority = CachePriority.VERY_LOW; + else + throw new InvalidConfigException(name); + + return true; + } + + public static bool ConfigCreatePolicy(XmlElement xmlElem, + string name, ref CreatePolicy createPolicy, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + if (xmlNode.InnerText == "ALWAYS") + createPolicy = CreatePolicy.ALWAYS; + else if (xmlNode.InnerText == "IF_NEEDED") + createPolicy = CreatePolicy.IF_NEEDED; + else if (xmlNode.InnerText == "NEVER") + createPolicy = CreatePolicy.NEVER; + else + throw new InvalidConfigException(name); + + return true; + } + + public static bool ConfigDuplicatesPolicy(XmlElement xmlElem, + string name, ref DuplicatesPolicy duplicatePolicy,bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + if (xmlNode.InnerText == "NONE") + duplicatePolicy = DuplicatesPolicy.NONE; + else if (xmlNode.InnerText == "SORTED") + duplicatePolicy = DuplicatesPolicy.SORTED; + else if (xmlNode.InnerText == "UNSORTED") + duplicatePolicy = DuplicatesPolicy.UNSORTED; + else + throw new InvalidConfigException(name); + + return true; + } + + public static bool ConfigDateTime(XmlElement xmlElem, + string name, ref DateTime time, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + time = DateTime.Parse(xmlNode.InnerText); + return true; + } + + public static bool ConfigDeadlockPolicy(XmlElement xmlElem, + string name, ref DeadlockPolicy deadlockPolicy, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + string policy = xmlNode.InnerText; + if (policy == "DEFAULT") + deadlockPolicy = DeadlockPolicy.DEFAULT; + else if (policy == "EXPIRE") + deadlockPolicy = DeadlockPolicy.EXPIRE; + else if (policy == "MAX_LOCKS") + deadlockPolicy = DeadlockPolicy.MAX_LOCKS; + else if (policy == "MAX_WRITE") + deadlockPolicy = DeadlockPolicy.MAX_WRITE; + else if (policy == "MIN_LOCKS") + deadlockPolicy = DeadlockPolicy.MIN_LOCKS; + else if (policy == "MIN_WRITE") + deadlockPolicy = DeadlockPolicy.MIN_WRITE; + else if (policy == "OLDEST") + deadlockPolicy = DeadlockPolicy.OLDEST; + else if (policy == "RANDOM") + deadlockPolicy = DeadlockPolicy.RANDOM; + else if (policy == "YOUNGEST") + deadlockPolicy = DeadlockPolicy.YOUNGEST; + else + throw new InvalidConfigException(name); + return true; + } + + public static bool ConfigEncryption(XmlElement xmlElem, + string name, DatabaseConfig dbConfig, bool compulsory) + { + EncryptionAlgorithm alg; + XmlNode xmlNode; + string tmp, password; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + password = XMLReader.GetNode((XmlElement)xmlNode, + "password").InnerText; + tmp = XMLReader.GetNode((XmlElement)xmlNode, "algorithm").InnerText; + if (tmp == "AES") + alg = EncryptionAlgorithm.AES; + else + alg = EncryptionAlgorithm.DEFAULT; + dbConfig.SetEncryption(password, alg); + return true; + } + + public static bool ConfigInt(XmlElement xmlElem, + string name, ref int value, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + value = int.Parse(xmlNode.InnerText); + return true; + } + + public static bool ConfigIsolation(XmlElement xmlElem, + string name, ref Isolation value, bool compulsory) + { + XmlNode xmlNode; + int isolationDegree; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + isolationDegree = int.Parse(xmlNode.InnerText); + if (isolationDegree == 1) + value = Isolation.DEGREE_ONE; + else if (isolationDegree == 2) + value = Isolation.DEGREE_TWO; + else if (isolationDegree == 3) + value = Isolation.DEGREE_THREE; + else + throw new InvalidConfigException(name); + + return true; + } + + public static bool ConfigLogFlush(XmlElement xmlElem, + string name, ref TransactionConfig.LogFlush value, + bool compulsory) + { + XmlNode xmlNode; + string logFlush; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + logFlush = xmlNode.InnerText; + if (logFlush == "DEFAULT") + value = TransactionConfig.LogFlush.DEFAULT; + else if (logFlush == "NOSYNC") + value = TransactionConfig.LogFlush.NOSYNC; + else if (logFlush == "WRITE_NOSYNC") + value = TransactionConfig.LogFlush.WRITE_NOSYNC; + else if (logFlush == "SYNC") + value = TransactionConfig.LogFlush.SYNC; + else + throw new InvalidConfigException(name); + + return true; + } + + public static bool ConfigLong(XmlElement xmlElem, + string name, ref long value, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + value = long.Parse(xmlNode.InnerText); + return true; + } + + public static bool ConfigMaxSequentialWrites( + XmlElement xmlElem, string name, + MPoolConfig mpoolConfig, bool compulsory) + { + XmlNode xmlNode; + uint pause; + int writes; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + pause = uint.Parse(XMLReader.GetNode( + (XmlElement)xmlNode, "pause").InnerText); + writes = int.Parse(XMLReader.GetNode( + (XmlElement)xmlNode,"maxWrites").InnerText); + mpoolConfig.SetMaxSequentialWrites(writes, pause); + return true; + } + + public static bool ConfigReplicationHostAddress( + XmlElement xmlElem, string name, + ref ReplicationHostAddress address, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode( + xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + address.Host = XMLReader.GetNode( + (XmlElement)xmlNode, "Host").InnerText; + address.Port = uint.Parse(XMLReader.GetNode( + (XmlElement)xmlNode, "Port").InnerText); + return true; + } + + public static bool ConfigString(XmlElement xmlElem, + string name, ref string valChar, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + valChar = xmlNode.InnerText; + return true; + } + + public static bool ConfigStringList(XmlElement xmlElem, + string name, ref List strings, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + XmlNodeList list = xmlNode.ChildNodes; + for (int i = 0; i < list.Count; i++) + strings.Add(list[i].InnerText); + + return true; + } + + public static bool ConfigUint(XmlElement xmlElem, + string name, ref uint value, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + value = uint.Parse(xmlNode.InnerText); + return true; + } + + public static bool ConfigVerboseMessages( + XmlElement xmlElem, string name, + ref VerboseMessages verbose, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, + name); + if (xmlNode == null && compulsory == false) + return false; + else if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + + ConfigBool((XmlElement)xmlNode, "AllFileOps", + ref verbose.AllFileOps, compulsory); + ConfigBool((XmlElement)xmlNode, "Deadlock", + ref verbose.Deadlock, compulsory); + ConfigBool((XmlElement)xmlNode, "FileOps", + ref verbose.FileOps, compulsory); + ConfigBool((XmlElement)xmlNode, "Recovery", + ref verbose.Recovery, compulsory); + ConfigBool((XmlElement)xmlNode, "Register", + ref verbose.Register, compulsory); + ConfigBool((XmlElement)xmlNode, "Replication", + ref verbose.Replication, compulsory); + ConfigBool((XmlElement)xmlNode, "ReplicationElection", + ref verbose.ReplicationElection, compulsory); + ConfigBool((XmlElement)xmlNode, "ReplicationLease", + ref verbose.ReplicationLease, compulsory); + ConfigBool((XmlElement)xmlNode, "ReplicationMessages", + ref verbose.ReplicationMessages, compulsory); + ConfigBool((XmlElement)xmlNode, "ReplicationMisc", + ref verbose.ReplicationMisc, compulsory); + ConfigBool((XmlElement)xmlNode, "ReplicationSync", + ref verbose.ReplicationSync, compulsory); + ConfigBool((XmlElement)xmlNode, "RepMgrConnectionFailure", + ref verbose.RepMgrConnectionFailure, compulsory); + ConfigBool((XmlElement)xmlNode, "RepMgrMisc", + ref verbose.RepMgrMisc, compulsory); + ConfigBool((XmlElement)xmlNode, "WaitsForTable", + ref verbose.WaitsForTable, compulsory); + return true; + } + + #endregion Config + + /* + * Confirm that the given value is the same with that in + * xml. If there is no testing data in xml and it is + * compulsory, the ConfigNotFoundException will be thrown. + * If there is no testing data and it is optional, nothing + * will be done. If any testing data is provided, the value + * will be checked. + */ + #region Confirm + public static void ConfirmAckPolicy(XmlElement xmlElem, + string name, AckPolicy ackPolicy, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, + name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + string policy = xmlNode.InnerText; + if (policy == "ALL") + Assert.AreEqual(AckPolicy.ALL, + ackPolicy); + else if (policy == "ALL_PEERS") + Assert.AreEqual(AckPolicy.ALL_PEERS, + ackPolicy); + else if (policy == "NONE") + Assert.AreEqual(AckPolicy.NONE, + ackPolicy); + else if (policy == "ONE") + Assert.AreEqual(AckPolicy.ONE, + ackPolicy); + else if (policy == "ONE_PEER") + Assert.AreEqual(AckPolicy.ONE_PEER, + ackPolicy); + else if (policy == "QUORUM") + Assert.AreEqual(AckPolicy.QUORUM, + ackPolicy); + else + throw new InvalidConfigException(name); + } + } + + public static void ConfirmBool(XmlElement xmlElem, + string name, bool value, bool compulsory) + { + XmlNode xmlNode; + bool expected; + + xmlNode = XMLReader.GetNode(xmlElem, + name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.ChildNodes.Count > 1) + { + expected = bool.Parse( + xmlNode.FirstChild.NextSibling.InnerText); + Assert.AreEqual(expected, value); + } + } + } + + /* + * If configure MACHINE, the ByteOrder in database will + * switch to LITTLE_ENDIAN or BIG_ENDIAN according to the + * current machine. + */ + public static void ConfirmByteOrder(XmlElement xmlElem, + string name, ByteOrder byteOrder, bool compulsory) + { + XmlNode xmlNode; + ByteOrder specOrder; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + specOrder = ByteOrder.FromConst(int.Parse( + xmlNode.InnerText)); + if (specOrder == ByteOrder.MACHINE) + Assert.AreNotEqual(specOrder, byteOrder); + else + Assert.AreEqual(specOrder, byteOrder); + } + } + + public static void ConfirmByteMatrix(XmlElement xmlElem, + string name, byte[,] byteMatrix, bool compulsory) + { + int i, j, matrixLen; + + XmlNode xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + /* + * If the length of the 2 matrixes are not + * the same, the matrixes are definately + * not equal. + */ + matrixLen = xmlNode.ChildNodes.Count; + Assert.AreEqual(matrixLen * matrixLen,byteMatrix.Length); + + /* + * Go over every element in the matrix to + * see if the same with the given xml data. + */ + for (i = 0; i < matrixLen; i++) + { + if (xmlNode.ChildNodes[i].ChildNodes.Count != matrixLen) + throw new ConfigNotFoundException(name); + for (j = 0; j < matrixLen; j++) + Assert.AreEqual( + byte.Parse(xmlNode.ChildNodes[i].ChildNodes[j].InnerText), + byteMatrix[i, j]); + } + } + } + + public static void ConfirmCachePriority(XmlElement xmlElem, + string name, CachePriority priority, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.InnerText == "DEFAULT") + Assert.AreEqual(CachePriority.DEFAULT, priority); + else if (xmlNode.InnerText == "HIGH") + Assert.AreEqual(CachePriority.HIGH, priority); + else if (xmlNode.InnerText == "LOW") + Assert.AreEqual(CachePriority.LOW, priority); + else if (xmlNode.InnerText == "VERY_HIGH") + Assert.AreEqual(CachePriority.VERY_HIGH, priority); + else if (xmlNode.InnerText == "VERY_LOW") + Assert.AreEqual(CachePriority.VERY_LOW, priority); + } + } + + public static void ConfirmCacheSize(XmlElement xmlElem, + string name, CacheInfo cache, bool compulsory) + { + uint bytes; + uint gigabytes; + int nCaches; + XmlNode xmlNode; + XmlNode xmlChildNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "Bytes")) != null) + { + bytes = uint.Parse(xmlChildNode.InnerText); + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "Gigabytes")) != null) + { + gigabytes = uint.Parse(xmlChildNode.InnerText); + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, + "NCaches")) != null) + { + nCaches = int.Parse(xmlChildNode.InnerText); + Assert.LessOrEqual(bytes, cache.Bytes); + Assert.AreEqual(gigabytes, cache.Gigabytes); + Assert.AreEqual(nCaches, cache.NCaches); + } + } + } + } + } + + /* + * If bytes in CacheSize is assigned, the bytes in cachesize + * couldn't be the default one. + */ + public static void ConfirmCacheSize(XmlElement xmlElem, + string name, CacheInfo cache, uint defaultCache, + bool compulsory) + { + uint bytes; + uint gigabytes; + int nCaches; + XmlNode xmlNode; + XmlNode xmlChildNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "Bytes")) != null) + { + bytes = defaultCache; + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "Gigabytes")) != null) + { + gigabytes = uint.Parse(xmlChildNode.InnerText); + if ((xmlChildNode = XMLReader.GetNode( + (XmlElement)xmlNode, "NCaches")) != null) + { + nCaches = int.Parse(xmlChildNode.InnerText); + Assert.AreNotEqual(bytes, cache.Bytes); + Assert.AreEqual(gigabytes, cache.Gigabytes); + Assert.AreEqual(nCaches, cache.NCaches); + } + } + } + } + } + + public static void ConfirmCreatePolicy(XmlElement xmlElem, + string name, CreatePolicy createPolicy, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.InnerText == "ALWAYS") + Assert.IsTrue(createPolicy.Equals(CreatePolicy.ALWAYS)); + else if (xmlNode.InnerText == "IF_NEEDED") + Assert.IsTrue(createPolicy.Equals(CreatePolicy.IF_NEEDED)); + else if (xmlNode.InnerText == "NEVER") + Assert.IsTrue(createPolicy.Equals(CreatePolicy.NEVER)); + } + } + + public static void ConfirmDataBaseType(XmlElement xmlElem, + string name, DatabaseType dbType, bool compulsory) + { + XmlNode xmlNode; + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.InnerText == "BTREE") + Assert.AreEqual(dbType, DatabaseType.BTREE); + else if (xmlNode.InnerText == "HASH") + Assert.AreEqual(dbType, DatabaseType.HASH); + else if (xmlNode.InnerText == "QUEUE") + Assert.AreEqual(dbType, DatabaseType.QUEUE); + else if (xmlNode.InnerText == "RECNO") + Assert.AreEqual(dbType, DatabaseType.RECNO); + else if (xmlNode.InnerText == "UNKNOWN") + Assert.AreEqual(dbType, DatabaseType.UNKNOWN); + } + } + + public static void ConfirmDateTime(XmlElement xmlElem, + string name, DateTime time, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + Assert.AreEqual(DateTime.Parse( + xmlNode.InnerText), time); + } + + public static void ConfirmDeadlockPolicy(XmlElement xmlElem, + string name, DeadlockPolicy deadlockPolicy, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + string policy = xmlNode.InnerText; + if (policy == "DEFAULT") + Assert.AreEqual(DeadlockPolicy.DEFAULT, deadlockPolicy); + else if (policy == "EXPIRE") + Assert.AreEqual(DeadlockPolicy.EXPIRE, deadlockPolicy); + else if (policy == "MAX_LOCKS") + Assert.AreEqual(DeadlockPolicy.MAX_LOCKS, deadlockPolicy); + else if (policy == "MAX_WRITE") + Assert.AreEqual(DeadlockPolicy.MAX_WRITE, deadlockPolicy); + else if (policy == "MIN_LOCKS") + Assert.AreEqual(DeadlockPolicy.MIN_LOCKS, deadlockPolicy); + else if (policy == "MIN_WRITE") + Assert.AreEqual(DeadlockPolicy.MIN_WRITE, deadlockPolicy); + else if (policy == "OLDEST") + Assert.AreEqual(DeadlockPolicy.OLDEST, deadlockPolicy); + else if (policy == "RANDOM") + Assert.AreEqual(DeadlockPolicy.RANDOM, deadlockPolicy); + else if (policy == "YOUNGEST") + Assert.AreEqual(DeadlockPolicy.YOUNGEST, deadlockPolicy); + else + throw new InvalidConfigException(name); + } + } + + public static void ConfirmDuplicatesPolicy( + XmlElement xmlElem, string name, + DuplicatesPolicy duplicatedPolicy, bool compulsory) + { + XmlNode xmlNode; + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.InnerText == "NONE") + Assert.AreEqual(duplicatedPolicy, DuplicatesPolicy.NONE); + else if (xmlNode.InnerText == "SORTED") + Assert.AreEqual(duplicatedPolicy, DuplicatesPolicy.SORTED); + else if (xmlNode.InnerText == "UNSORTED") + Assert.AreEqual(duplicatedPolicy, DuplicatesPolicy.UNSORTED); + } + } + + public static void ConfirmEncryption(XmlElement xmlElem, + string name, string dPwd, EncryptionAlgorithm dAlg, bool compulsory) + { + EncryptionAlgorithm alg; + XmlNode xmlNode = XMLReader.GetNode(xmlElem, + name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + string password = XMLReader.GetNode( + (XmlElement)xmlNode, "password").InnerText; + string tmp = XMLReader.GetNode( + (XmlElement)xmlNode, "algorithm").InnerText; + if (tmp == "AES") + alg = EncryptionAlgorithm.AES; + else + alg = EncryptionAlgorithm.DEFAULT; + Assert.AreEqual(dAlg, alg); + Assert.AreEqual(dPwd, dPwd); + } + } + + public static void ConfirmInt(XmlElement xmlElem, + string name, int value, bool compulsory) + { + XmlNode xmlNode; + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + Assert.AreEqual(int.Parse(xmlNode.InnerText), value); + } + + public static void ConfirmIsolation(XmlElement xmlElem, + string name, Isolation value, bool compulsory) + { + XmlNode xmlNode; + int isolationDegree; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + isolationDegree = int.Parse(xmlNode.InnerText); + if (isolationDegree == 1) + Assert.AreEqual(Isolation.DEGREE_ONE, value); + else if (isolationDegree == 2) + Assert.AreEqual(Isolation.DEGREE_TWO, value); + else if (isolationDegree == 3) + Assert.AreEqual(Isolation.DEGREE_THREE, value); + else + throw new InvalidConfigException(name); + } + } + + public static void ConfirmLogFlush(XmlElement xmlElem, + string name, TransactionConfig.LogFlush value, + bool compulsory) + { + XmlNode xmlNode; + string logFlush; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + logFlush = xmlNode.InnerText; + if (logFlush == "DEFAULT") + Assert.AreEqual(TransactionConfig.LogFlush.DEFAULT, value); + else if (logFlush == "NOSYNC") + Assert.AreEqual(TransactionConfig.LogFlush.NOSYNC, value); + else if (logFlush == "WRITE_NOSYNC") + Assert.AreEqual(TransactionConfig.LogFlush.WRITE_NOSYNC, value); + else if (logFlush == "SYNC") + Assert.AreEqual(TransactionConfig.LogFlush.SYNC, value); + else + throw new InvalidConfigException(name); + } + } + + public static void ConfirmLong(XmlElement xmlElem, + string name, long value, bool compulsory) + { + XmlNode xmlNode; + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + Assert.AreEqual(long.Parse(xmlNode.InnerText), value); + } + + public static void ConfirmMaxSequentialWrites( + XmlElement xmlElem, string name, + uint mPause, int mWrites, bool compulsory) + { + XmlNode xmlNode; + uint pause; + int writes; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + writes = int.Parse(XMLReader.GetNode( + (XmlElement)xmlNode, "maxWrites").InnerText); + pause = uint.Parse(XMLReader.GetNode( + (XmlElement)xmlNode, "pause").InnerText); + + Assert.AreEqual(mPause, pause); + Assert.AreEqual(mWrites, writes); + } + } + + public static void ConfirmReplicationHostAddress( + XmlElement xmlElem, string name, + ReplicationHostAddress address, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + string host = XMLReader.GetNode( + (XmlElement)xmlNode, "Host").InnerText; + uint port = uint.Parse(XMLReader.GetNode( + (XmlElement)xmlNode, "Port").InnerText); + + Assert.AreEqual(host, address.Host); + Assert.AreEqual(port, address.Port); + } + } + + public static void ConfirmString(XmlElement xmlElem, + string name, string str, bool compulsory) + { + XmlNode xmlNode; + + if (str != null) + { + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.HasChildNodes) + Assert.AreEqual( + xmlNode.FirstChild.InnerText, str); + } + } + } + + public static void ConfirmStringList(XmlElement xmlElem, + string name, List strings, bool compulsory) + { + XmlNode xmlNode; + + if (strings != null) + { + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + if (xmlNode.HasChildNodes) + { + XmlNodeList list = xmlNode.ChildNodes; + for (int i = 0; i < xmlNode.ChildNodes.Count;i++) + Assert.IsTrue( + strings.Contains(list[i].InnerText)); + } + } + } + } + + public static void ConfirmUint(XmlElement xmlElem, + string name, uint value, bool compulsory) + { + XmlNode xmlNode; + + xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + Assert.AreEqual(uint.Parse(xmlNode.InnerText), value); + } + + public static void ConfirmVerboseMessages( + XmlElement xmlElem, string name, + VerboseMessages verbose, bool compulsory) + { + XmlNode xmlNode = XMLReader.GetNode(xmlElem, name); + if (xmlNode == null && compulsory == true) + throw new ConfigNotFoundException(name); + else if (xmlNode != null) + { + ConfirmBool((XmlElement)xmlNode, "AllFileOps", + verbose.AllFileOps, compulsory); + ConfirmBool((XmlElement)xmlNode, "Deadlock", + verbose.Deadlock, compulsory); + ConfirmBool((XmlElement)xmlNode, "FileOps", + verbose.FileOps, compulsory); + ConfirmBool((XmlElement)xmlNode, "Recovery", + verbose.Recovery, compulsory); + ConfirmBool((XmlElement)xmlNode, "Register", + verbose.Register, compulsory); + ConfirmBool((XmlElement)xmlNode, "Replication", + verbose.Replication, compulsory); + ConfirmBool((XmlElement)xmlNode, "ReplicationElection", + verbose.ReplicationElection, compulsory); + ConfirmBool((XmlElement)xmlNode, "ReplicationLease", + verbose.ReplicationLease, compulsory); + ConfirmBool((XmlElement)xmlNode, "ReplicationMessages", + verbose.ReplicationMessages, compulsory); + ConfirmBool((XmlElement)xmlNode, "ReplicationMisc", + verbose.ReplicationMisc, compulsory); + ConfirmBool((XmlElement)xmlNode, "ReplicationSync", + verbose.ReplicationSync, compulsory); + ConfirmBool((XmlElement)xmlNode, "RepMgrConnectionFailure", + verbose.RepMgrConnectionFailure, compulsory); + ConfirmBool((XmlElement)xmlNode, "RepMgrMisc", + verbose.RepMgrMisc, compulsory); + ConfirmBool((XmlElement)xmlNode,"WaitsForTable", + verbose.WaitsForTable, compulsory); + } + } + #endregion Confirm + + public static void dbtFromString(DatabaseEntry dbt, string s) + { + dbt.Data = System.Text.Encoding.ASCII.GetBytes(s); + } + + public static string strFromDBT(DatabaseEntry dbt) + { + + System.Text.ASCIIEncoding decode = new ASCIIEncoding(); + return decode.GetString(dbt.Data); + } + + /* + * Reading params successfully returns true. Unless returns + * false. The retrieved Xml fragment is returning in xmlElem. + */ + public static XmlElement TestSetUp(string testFixtureName, string testName) + { + XMLReader xmlReader = new XMLReader("../../AllTestData.xml"); + XmlElement xmlElem = xmlReader.GetXmlElement(testFixtureName, testName); + if (xmlElem == null) + throw new ConfigNotFoundException(testFixtureName + ":" + testName); + else + return xmlElem; + } + + /* + * Delete existing test output directory and its files, + * then create a new one. + */ + public static void ClearDir(string testDir) + { + if (Directory.Exists(testDir)) + Directory.Delete(testDir, true); + Directory.CreateDirectory(testDir); + } + } +} -- cgit v1.2.3