mirror of
https://github.com/berkeleydb/libdb.git
synced 2024-11-16 17:16:25 +00:00
1119 lines
34 KiB
C#
1119 lines
34 KiB
C#
/*-
|
|
* See the file LICENSE for redistribution information.
|
|
*
|
|
* Copyright (c) 2009, 2011 Oracle and/or its affiliates. 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
|
|
{
|
|
public static Random random = new Random();
|
|
|
|
/*
|
|
* 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 DbSiteConfig siteConfig, 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);
|
|
|
|
siteConfig.Host = XMLReader.GetNode(
|
|
(XmlElement)xmlNode, "Host").InnerText;
|
|
siteConfig.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<string> 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,
|
|
DbSiteConfig siteConfig, 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, siteConfig.Host);
|
|
Assert.AreEqual(port, siteConfig.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<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 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);
|
|
}
|
|
|
|
public static string RandomString(int max) {
|
|
string text = "";
|
|
int len = random.Next(max);
|
|
|
|
for (int i = 0; i < len; i++)
|
|
text += "a";
|
|
|
|
return text;
|
|
}
|
|
}
|
|
}
|