public void CreateFrom002Objects()
{
var exPerf = new ExaArray1D <object>(Strategy.MAX_PERFORMANCE);
exPerf.Extend(2);
exPerf[0] = new object();
exPerf[1] = new object();
var next = ExaArray1D <object> .CreateFrom(exPerf);
Assert.That(next.Length, Is.EqualTo(exPerf.Length));
Assert.That(next.OptimizationStrategy, Is.EqualTo(exPerf.OptimizationStrategy));
Assert.That(next[0], Is.SameAs(exPerf[0]));
Assert.That(next[1], Is.SameAs(exPerf[1]));
Assert.That(next[0], Is.Not.SameAs(next[1]));
exPerf = null;
next = null;
var exElem = new ExaArray1D <object>(Strategy.MAX_ELEMENTS);
exElem.Extend(2);
exElem[0] = new object();
exElem[1] = new object();
next = ExaArray1D <object> .CreateFrom(exElem);
Assert.That(next.Length, Is.EqualTo(exElem.Length));
Assert.That(next.OptimizationStrategy, Is.EqualTo(exElem.OptimizationStrategy));
Assert.That(next[0], Is.SameAs(exElem[0]));
Assert.That(next[1], Is.SameAs(exElem[1]));
Assert.That(next[0], Is.Not.SameAs(next[1]));
}
public void CreateFrom001()
{
var exPerf = new ExaArray1D <byte>(Strategy.MAX_PERFORMANCE);
exPerf.Extend(2);
exPerf[0] = 0x01;
exPerf[1] = 0x02;
var next = ExaArray1D <byte> .CreateFrom(exPerf);
Assert.That(next.Length, Is.EqualTo(exPerf.Length));
Assert.That(next.OptimizationStrategy, Is.EqualTo(exPerf.OptimizationStrategy));
Assert.That(next.Items(), Is.EquivalentTo(exPerf.Items()));
exPerf = null;
next = null;
var exElem = new ExaArray1D <byte>(Strategy.MAX_ELEMENTS);
exElem.Extend(2);
exElem[0] = 0x03;
exElem[1] = 0x04;
next = ExaArray1D <byte> .CreateFrom(exElem);
Assert.That(next.Length, Is.EqualTo(exElem.Length));
Assert.That(next.OptimizationStrategy, Is.EqualTo(exElem.OptimizationStrategy));
Assert.That(next.Items(), Is.EquivalentTo(exElem.Items()));
}
public void ExtendingTooFar01()
{
var exaA = new ExaArray1D <byte>();
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
// Cannot handle more than 1.1 quintillion elements:
exaA.Extend(ulong.MaxValue);
});
}
public void CreateFrom003()
{
var exPerf = new ExaArray1D <byte>(Strategy.MAX_PERFORMANCE);
exPerf.Extend(5_000_000_000); // more than one chunk
var next = ExaArray1D <byte> .CreateFrom(exPerf);
Assert.That(next.Length, Is.EqualTo(exPerf.Length));
Assert.DoesNotThrow(() => { next[4_999_999_999] = 0xab; });
public void ExtendingToEndFirstChunk01()
{
const uint MAX = 1_073_741_824;
var exaA = new ExaArray1D <byte>(Strategy.MAX_PERFORMANCE);
exaA.Extend(MAX - 2);
Assert.That(exaA.Length, Is.EqualTo(MAX - 2));
exaA.Extend(2);
Assert.That(exaA.Length, Is.EqualTo(MAX));
}
public void CountingHugeSize01()
{
var exaA = new ExaArray1D <byte>();
exaA.Extend(5_000_000_000);
Assert.That(exaA.Length, Is.EqualTo(5_000_000_000));
Assert.Throws <OverflowException>(() =>
{
// Cannot work because linq uses int:
var n = exaA.Items().Count();
});
}
public void CreatingNormalSize02()
{
var exaA = new ExaArray1D <int>();
exaA.Extend(1_000_000);
Assert.That(exaA.Length, Is.EqualTo(1_000_000));
for (ulong n = 0; n < 1_000_000; n++)
{
exaA[n] = (int)(n * n);
}
Assert.That(exaA.Items().Count(), Is.EqualTo(1_000_000));
exaA.Extend();
Assert.That(exaA.Length, Is.EqualTo(1_000_001));
}
public void SetInvalidIndex01()
{
var exaPerf = new ExaArray1D <byte>(Strategy.MAX_PERFORMANCE);
exaPerf.Extend(2);
Assert.Throws <IndexOutOfRangeException>(() =>
{
exaPerf[ulong.MaxValue] = 0x00; // Because index >= max
});
Assert.DoesNotThrow(() =>
{
exaPerf[0] = 0x01;
exaPerf[1] = 0x02;
});
Assert.Throws <IndexOutOfRangeException>(() =>
{
var t = exaPerf[2] = 0x03; // Because we don't allocate
});
exaPerf = null;
var exaElem = new ExaArray1D <byte>(Strategy.MAX_ELEMENTS);
exaElem.Extend(2);
Assert.Throws <IndexOutOfRangeException>(() =>
{
exaElem[ulong.MaxValue] = 0x00; // Because index >= max
});
Assert.DoesNotThrow(() =>
{
exaElem[0] = 0x01;
exaElem[1] = 0x02;
});
Assert.Throws <IndexOutOfRangeException>(() =>
{
exaElem[2] = 0x03; // Because we don't allocate
});
}
public void CreatingNormalSize01()
{
var exaA = new ExaArray1D <byte>();
Assert.That(exaA.Length, Is.EqualTo(0));
Assert.Throws <IndexOutOfRangeException>(() =>
{
var n = exaA[0];
});
Assert.That(exaA.Items(), Is.Empty);
exaA.Extend();
Assert.That(exaA.Length, Is.EqualTo(1));
Assert.That(exaA.Items(), Is.EquivalentTo(new[] { 0x00 }));
Assert.That(exaA[0], Is.EqualTo(0));
exaA[0] = 0xFF;
Assert.That(exaA.Length, Is.EqualTo(1));
Assert.That(exaA.Items(), Is.EquivalentTo(new[] { 0xFF }));
Assert.That(exaA[0], Is.EqualTo(0xFF));
}
