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 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 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 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 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 void ConfirmStringList(XmlElement xmlElem,
string name, List <string> 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 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 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 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 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 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 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);
}
/*
* 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 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 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);
}
}
}
/*
* 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);
}
}
/*
* 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 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 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);
}
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 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 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 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 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 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 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 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 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 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 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);
}
}
}
}
}
/*
* 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;
}
