public static int Main()
{
int size = 10;
int i, j, k, l, m;
double sum = 0;
ArrayHolder ArrayHolderInst = new ArrayHolder();
for (i = 0; i < size; i++)
{
ArrayHolderInst.GenArray[i] = new Gen <int> [i][][][];
for (j = 0; j < i; j++)
{
ArrayHolderInst.GenArray[i][j] = new Gen <int> [j][][];
for (k = 0; k < j; k++)
{
ArrayHolderInst.GenArray[i][j][k] = new Gen <int> [k][];
for (l = 0; l < k; l++)
{
ArrayHolderInst.GenArray[i][j][k][l] = new Gen <int> [l];
for (m = 0; m < l; m++)
{
ArrayHolderInst.GenArray[i][j][k][l][m] = new Gen <int>(i * j * k * l * m);
}
}
}
}
}
for (i = 0; i < size; i++)
{
for (j = 0; j < i; j++)
{
for (k = 0; k < j; k++)
{
for (l = 0; l < k; l++)
{
for (m = 0; m < l; m++)
{
sum += ArrayHolderInst.GenArray[i][j][k][l][m].Fld1;
}
}
}
}
}
Eval(sum == 269325);
sum = 0;
if (result)
{
Console.WriteLine("Test Passed");
return(100);
}
else
{
Console.WriteLine("Test Failed");
return(1);
}
}
public virtual void Test()
{
if (!A().Provider().SupportsMultiDimensionalArrays())
{
return;
}
if (!B().Provider().SupportsMultiDimensionalArrays())
{
return;
}
ArrayHolder h1 = new ArrayHolder("h1");
ArrayHolder h2 = new ArrayHolder("h2");
h1._array = new ArrayHolder[] { h1 };
h2._array = new ArrayHolder[] { h1, h2, null };
h1._arrayN = new ArrayHolder[][] { new ArrayHolder[] { h1 } };
h2._arrayN = new ArrayHolder[][] { new ArrayHolder[] { h1, null }, new ArrayHolder
[] { null, h2 }, new ArrayHolder[] { null, null } };
//TODO Fix ReflectArray.shape() and test with innermost arrays of varying sizes: {{h1}, {null, h2}, {null}}
B().Provider().StoreNew(h2);
B().Provider().StoreNew(h1);
B().Provider().Commit();
IReplicationSession replication = new GenericReplicationSession(A().Provider(), B
().Provider(), null, _fixtures.reflector);
replication.Replicate(h2);
//Traverses to h1.
replication.Commit();
IEnumerator objects = A().Provider().GetStoredObjects(typeof(ArrayHolder)).GetEnumerator
();
CheckNext(objects);
CheckNext(objects);
Assert.IsFalse(objects.MoveNext());
}
private object ProcessArrayOrNewCollection(object collection, PersistentCollectionType collectionType)
{
if (collection == null)
{
return(null);
}
ICollectionPersister persister = Session.GetCollectionPersister(collectionType.Role);
if (collectionType.IsArrayType)
{
ArrayHolder ah = Session.GetArrayHolder(collection);
if (ah == null)
{
ah = new ArrayHolder(Session, collection);
Session.AddNewCollection(ah, persister);
Session.AddArrayHolder(ah);
}
return(null);
}
else
{
PersistentCollection persistentCollection = collectionType.Wrap(Session, collection);
Session.AddNewCollection(persistentCollection, persister);
if (log.IsDebugEnabled)
{
log.Debug("Wrapped collection in role: " + collectionType.Role);
}
return(persistentCollection); //Force a substitution!
}
}
/// <Summary>
/// 計測用配列リストから、確認対象の配列をコピーして返します。
/// </Summary>
/// <param id="index">リスト内のインデックス</param>
protected int[] GetTargetArray(int index)
{
// 対象のArrayHolderを取得します。
ArrayHolder holder = targetArrays[index];
// ArrayHolderから配列をコピーして返します。
int[] array = (int[])holder.targetArray.Clone();
return(array);
}
protected virtual void CheckH2(ArrayHolder holder)
{
Assert.AreEqual(holder.Array()[0].GetName(), "h1");
Assert.AreEqual(holder.Array()[1], holder);
Assert.AreEqual(holder.Array()[2], null);
Assert.AreEqual(holder.ArrayN()[0][0].GetName(), "h1");
Assert.AreEqual(holder.ArrayN()[1][0], null);
Assert.AreEqual(holder.ArrayN()[1][1], holder);
Assert.AreEqual(holder.ArrayN()[2][0], null);
}
public static unsafe void ReadRawValues(
this PdhCounter counter,
ArrayHolder arrayHolder,
InstancesCounter instancesCounter,
List <Sample> samples,
out int size)
{
samples.Clear();
instancesCounter.Clear();
while (true)
{
size = counter.EstimateRawCounterArraySize();
if (size == 0)
{
return;
}
var buffer = arrayHolder.Get(size);
fixed(byte *b = buffer)
{
var ptr = (PDH_RAW_COUNTER_ITEM *)b;
var status = counter.GetRawCounterArray(ref size, out var items, ptr);
if (status == PdhStatus.PDH_CSTATUS_INVALID_DATA)
{
return;
}
if (status == PdhStatus.PDH_MORE_DATA)
{
continue;
}
status.EnsureSuccess(nameof(PdhExports.PdhGetFormattedCounterArray));
if (items * sizeof(PDH_RAW_COUNTER_ITEM) > buffer.Length)
{
throw new InvalidOperationException($"Buffer overflow check failed. ItemCount: {items}, ItemSize: {sizeof(PDH_FMT_COUNTERVALUE_ITEM)}, BufferSize: {buffer.Length}");
}
for (var i = 0; i < items; ++i)
{
var current = ptr + i;
var instanceName = new string(current->Name); // TODO: avoid allocation here
samples.Add(
new Sample
{
Instance = instanceName,
Value = current->RawValue.FirstValue,
Id = instancesCounter.GetAndIncrement(instanceName)
});
}
break;
}
}
}
private void Check(ArrayHolder holder)
{
if (holder.GetName().Equals("h1"))
{
CheckH1(holder);
}
else
{
CheckH2(holder);
}
}
public void TestTemplateForGetEnumerator()
{
var holder = new ArrayHolder(new[] { 1, 2, 3 });
int i = 0;
foreach (var item in holder)
{
Assert.AreEqual(++i, item);
}
}
public static void SaveArray <T>(this T[] obj, string file)
{
if (!File.Exists(file))
{
Debug.Log("path directory doesnt exist");
return;
}
var convertedObj = new ArrayHolder <T>(obj);
string saveTxt = JsonConvert.SerializeObject(convertedObj);
using StreamWriter writer = new StreamWriter(file);
writer.Write(saveTxt);
}
public static int Main()
{
int size = 10;
int i, j, k;
double sum = 0;
int cLoc = 0;
ArrayHolder ArrayHolderInst = new ArrayHolder();
for (i = 0; (i < size); i++)
{
for (j = 0; (j < size); j++)
{
for (k = 0; (k < size); k++)
{
ArrayHolderInst.GenArray[i, j, k] = new Gen <int>(cLoc);
cLoc++;
}
}
}
for (i = 0; (i < size); i++)
{
for (j = 0; (j < size); j++)
{
for (k = 0; (k < size); k++)
{
sum += ArrayHolderInst.GenArray[i, j, k].Fld1;
cLoc++;
}
}
}
Eval(sum == 499500);
sum = 0;
if (result)
{
Console.WriteLine("Test Passed");
return(100);
}
else
{
Console.WriteLine("Test Failed");
return(1);
}
}
public void ShouldSerializeNullArrayMember()
{
var expected = new ArrayHolder
{
ByteArray = new byte[] { 1, 2, 3 },
ObjectArray = new object[] { new SimpleType {
TextA = "a", TextB = "b"
}, 5, "test", null }
};
byte[] serialized = _serializer.Serialize(expected);
var actual = _serializer.Deserialize <ArrayHolder>(serialized);
AssertProperties(expected, actual);
}
public void TestObjectArrayMember()
{
object[] array = new object[] { TestRandomizer.GetString(), TestRandomizer.GetInt(), TestRandomizer.GetDecimal() };
ArrayHolder ah = new ArrayHolder();
ah.RandomNumber = TestRandomizer.GetInt();
ah.Array = array;
string xml = xstream.ToXml(ah);
ArrayHolder ahRev = xstream.FromXml(xml) as ArrayHolder;
Assert.IsNotNull(ahRev);
Assert.AreEqual(ah.RandomNumber, ahRev.RandomNumber);
Assert.AreEqual(ah.Array, ahRev.Array);
}
static string JustReadFromAnArrayALot(int acountCount, int runs, int warmUpRuns)
{
var rand = new Random();
List <Action> actions = null;
ArrayHolder ah = new ArrayHolder();
Action stepUp = () =>
{
var tree = new string[100];
for (int i = 0; i < 100; i++)
{
tree[i] = "thing " + i;
}
ah.array = tree;
Action action = () =>
{
var _ = ah.array.Span[(int)rand.Next(100)];
};
actions = new List <Action>();
for (int i = 0; i < acountCount; i++)
{
actions.Add(action);
}
};
Action run = () =>
{
Parallel.Invoke(actions.ToArray());
};
return(MyStupidBenchmarker.Benchmark(stepUp, run, runs, warmUpRuns).ToString());
}
internal TermInfosReader(Directory dir, System.String seg, FieldInfos fis, int readBufferSize, int indexDivisor, IState state)
{
bool success = false;
if (indexDivisor < 1 && indexDivisor != -1)
{
throw new System.ArgumentException("indexDivisor must be -1 (don't load terms index) or greater than 0: got " + indexDivisor);
}
try
{
directory = dir;
segment = seg;
fieldInfos = fis;
origEnum = new SegmentTermEnum(directory.OpenInput(segment + "." + IndexFileNames.TERMS_EXTENSION, readBufferSize, state), fieldInfos, false, state);
size = origEnum.size;
if (indexDivisor != -1)
{
// Load terms index
totalIndexInterval = origEnum.indexInterval * indexDivisor;
var indexEnum = new SegmentTermEnum(directory.OpenInput(segment + "." + IndexFileNames.TERMS_INDEX_EXTENSION, readBufferSize, state), fieldInfos, true, state);
try
{
int indexSize = 1 + ((int)indexEnum.size - 1) / indexDivisor; // otherwise read index
_holder?.Dispose();
_holder = new ArrayHolder(indexSize);
for (int i = 0; indexEnum.Next(state); i++)
{
indexTerms[i] = indexEnum.Term;
indexInfos[i] = indexEnum.TermInfo();
indexPointers[i] = indexEnum.indexPointer;
for (int j = 1; j < indexDivisor; j++)
{
if (!indexEnum.Next(state))
{
break;
}
}
}
}
finally
{
indexEnum.Close();
}
}
else
{
// Do not load terms index:
totalIndexInterval = -1;
_holder?.Dispose();
}
success = true;
}
finally
{
// With lock-less commits, it's entirely possible (and
// fine) to hit a FileNotFound exception above. In
// this case, we want to explicitly close any subset
// of things that were opened so that we don't have to
// wait for a GC to do so.
if (!success)
{
Dispose();
}
}
}
protected virtual void CheckH1(ArrayHolder holder)
{
Assert.AreEqual(holder.Array()[0], holder);
Assert.AreEqual(holder.ArrayN()[0][0], holder);
}
static void Main()
{
ArrayHolder holder = new ArrayHolder();
ref int x = ref holder[0];
