public int Empty(Reservoire into) { int amount = this.CurrentFill; into.PutWater(amount); this.CurrentFill = 0; return amount; }
public object Clone() { var clone = new Reservoire(); clone.VolumeUsed = this.VolumeUsed; clone.VolumeThrownOut = this.VolumeThrownOut; return clone; }
public BaseSolutionStrategy(string name, int waterGoal, Reservoire waterSource) { if (waterSource == null) { throw new ArgumentNullException("waterSource"); } StrategyName = name; WaterGoal = waterGoal; WaterSource = waterSource.Clone() as Reservoire; }
public void TestReservoireBasicGet() { // Arrange int numAmounts = Rand.Next(5000, 10000), iterations = 0; int[] amounts = new int[numAmounts], totals = new int[numAmounts]; int amount = 0; long longTotal = 0; for (int a = 0; a < numAmounts; a++) { amount = Rand.Next(1, 30000); longTotal += amount; if ((longTotal >> 32) > 0) { iterations = a; break; } amounts[a] = amount; totals[a] = (int)longTotal; } if (iterations == 0) { iterations = numAmounts; amount = Rand.Next(int.MaxValue - totals[totals.Length - 1] + 2, int.MaxValue - 1); longTotal += amount; } Reservoire utReservoire = new Reservoire(); int amountGotten = 0; for (int i = 0; i < iterations; i++) { // Act amountGotten = utReservoire.GetWater(amounts[i]); // Assert Assert.AreEqual(amounts[i], amountGotten, "GetWater returned different amount that requested [i=" + i + "/" + iterations + "]"); Assert.AreEqual(totals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + iterations + "]"); } int noGet = -1; try { noGet = utReservoire.GetWater(amount); } catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "GetWater ArgumentOutOfRangeException didn't report 'amount' parameter"); Assert.AreEqual(-1, noGet, "Reservoire GetWater returned value == " + noGet + " even though ArgumentOutOfRangeException was thrown for getting too much water"); } catch (Exception ex) { Assert.Fail("GetWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when VolumeUsed == " + totals[iterations - 1] + " && get amount == " + amount); } Assert.IsTrue(CaughtEx, "GetWater did not throw ArgumentOutOfRangeException when VolumeUsed == " + totals[iterations - 1] + " && get amount == " + amount); }
public Problem(Bucket first, Bucket second, int goalWaterVolume) { if (goalWaterVolume < 0) { throw new ArgumentOutOfRangeException("Cannot solve for a problem with a negative goal"); } FirstBucket = first; SecondBucket = second; WaterSource = new Reservoire(); GoalWaterVolume = goalWaterVolume; }
public SingleBucketSolutionStrategy(string name, Bucket from, Bucket to, int waterGoal, Reservoire waterSource) : base(name, waterGoal, waterSource) { if (from == null) { throw new ArgumentNullException("from"); } if (to == null) { throw new ArgumentNullException("to"); } From = from.Clone() as Bucket; To = to.Clone() as Bucket; }
public void TestReservoireGetWaterRandomLargeInts() { // Arrange int numIterations = Rand.Next(5000, 10000); for (int i = 0; i < numIterations; i++) { Reservoire utReservoire = new Reservoire(); // Act int randWayBig = Rand.Next(1000000, int.MaxValue - 1); int randWayBigGot = utReservoire.GetWater(randWayBig); // Assert Assert.AreEqual(randWayBig, randWayBigGot, "Getting random way big (" + randWayBig + ") water returned different amount of water [i=" + i + "/" + numIterations + "]"); Assert.AreEqual(randWayBig, utReservoire.VolumeUsed, "VolumeUsed isn't random way big (" + randWayBig + ") when getting random way big (" + randWayBig + ") water [i=" + i + "/" + numIterations + "]"); } }
public void TestReservoireGetWaterGreaterThanIntMax() { // Arrange int getAmount = 1, wayBig = int.MaxValue; Reservoire utReservoire = new Reservoire(); // Act int gotAmount = utReservoire.GetWater(getAmount); int gotVolume = utReservoire.VolumeUsed; int tooMuch = -1; try { tooMuch = utReservoire.GetWater(wayBig); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "ArgumentOutOfRangeException didn't report 'amount' parameter"); Assert.AreEqual(-1, tooMuch, "Reservoire GetWater returned value == " + tooMuch + " even though ArgumentOutOfRangeException was thrown for getting too much water"); } catch (Exception ex) { Assert.Fail("GetWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when VolumeUsed == " + gotVolume + " && get amount == " + wayBig); } Assert.IsTrue(CaughtEx, "GetWater did not throw ArgumentOutOfRangeException when VolumeUsed == " + gotVolume + " && get amount == " + wayBig); }
public void TestReservoireGetWaterIntMax() { // Arrange int wayBig = int.MaxValue; Reservoire utReservoire = new Reservoire(); // Act int gotWayBig = utReservoire.GetWater(wayBig); // Assert Assert.AreEqual(wayBig, gotWayBig, "Getting int.MaxValue water returned different amount of water"); Assert.AreEqual(wayBig, utReservoire.VolumeUsed, "VolumeUsed isn't int.MaxValue when getting int.MaxValue water"); }
public void TestBucketToFromBytes() { // Arrange Bucket sourceBucket = new Bucket(54, "SourceBucket"); Bucket otherBucket = new Bucket(4, "OtherBucket"); Encoding textEncoding = Encoding.UTF8; Bucket utNewBucket = new Bucket(); Bucket utFullBucket = new Bucket(); Bucket utTransBucket = new Bucket(); Bucket utEmptiedBucket = new Bucket(); Bucket utNewBucketFromBuffer = new Bucket(); Bucket utFullBucketFromBuffer = new Bucket(); Bucket utTransBucketFromBuffer = new Bucket(); Bucket utEmptiedBucketFromBuffer = new Bucket(); Reservoire waterSrc = new Reservoire(); // Act byte[] utNewBytes = sourceBucket.GetBytes(textEncoding); sourceBucket.Fill(waterSrc); byte[] utFullBytes = sourceBucket.GetBytes(textEncoding); sourceBucket.TransferTo(otherBucket); byte[] utTransBytes = sourceBucket.GetBytes(textEncoding); sourceBucket.Empty(waterSrc); byte[] utEmptiedBytes = sourceBucket.GetBytes(textEncoding); utNewBucket.FromBytes(utNewBytes, textEncoding: textEncoding); utFullBucket.FromBytes(utFullBytes, textEncoding: textEncoding); utTransBucket.FromBytes(utTransBytes, textEncoding: textEncoding); utEmptiedBucket.FromBytes(utEmptiedBytes, textEncoding: textEncoding); byte[] utBuffer = new byte[utNewBytes.Length + utFullBytes.Length + utTransBytes.Length + utEmptiedBytes.Length]; int toBufferOffset = 0; toBufferOffset = utNewBucket.OntoBuffer(utBuffer, toBufferOffset, textEncoding); toBufferOffset = utFullBucket.OntoBuffer(utBuffer, toBufferOffset, textEncoding); toBufferOffset = utTransBucket.OntoBuffer(utBuffer, toBufferOffset, textEncoding); toBufferOffset = utEmptiedBucket.OntoBuffer(utBuffer, toBufferOffset, textEncoding); int fromBufferOffset = 0; fromBufferOffset = utNewBucketFromBuffer.FromBytes(utBuffer, fromBufferOffset, textEncoding); fromBufferOffset = utFullBucketFromBuffer.FromBytes(utBuffer, fromBufferOffset, textEncoding); fromBufferOffset = utTransBucketFromBuffer.FromBytes(utBuffer, fromBufferOffset, textEncoding); fromBufferOffset = utEmptiedBucketFromBuffer.FromBytes(utBuffer, fromBufferOffset, textEncoding); // Assert Assert.AreEqual(sourceBucket.Capacity, utNewBucket.Capacity, "Retrieved new bucket has different capacity"); Assert.AreEqual(0, utNewBucket.CurrentFill, "Retrieved new bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utNewBucket.Name, "Retrieved new bucket has wrong name"); Assert.IsTrue(utNewBucket.IsEmpty, "Retrieved new bucket is not empty"); Assert.IsFalse(utNewBucket.IsFull, "Retrieved new bucket is full"); Assert.AreEqual(sourceBucket.Capacity, utFullBucket.Capacity, "Retrieved full bucket has different capacity"); Assert.AreEqual(sourceBucket.Capacity, utFullBucket.CurrentFill, "Retrieved full bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utFullBucket.Name, "Retrieved full bucket has wrong name"); Assert.IsFalse(utFullBucket.IsEmpty, "Retrieved full bucket is empty"); Assert.IsTrue(utFullBucket.IsFull, "Retrieved full bucket is not full"); Assert.AreEqual(sourceBucket.Capacity, utTransBucket.Capacity, "Retrieved transferred bucket has different capacity"); Assert.AreEqual(sourceBucket.Capacity - otherBucket.Capacity, utTransBucket.CurrentFill, "Retrieved transferred bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utTransBucket.Name, "Retrieved transferred bucket has wrong name"); Assert.IsFalse(utTransBucket.IsEmpty, "Retrieved transferred bucket is empty"); Assert.IsFalse(utTransBucket.IsFull, "Retrieved transferred bucket is full"); Assert.AreEqual(sourceBucket.Capacity, utEmptiedBucket.Capacity, "Retrieved emptied bucket has different capacity"); Assert.AreEqual(0, utEmptiedBucket.CurrentFill, "Retrieved emptied bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utEmptiedBucket.Name, "Retrieved emptied bucket has wrong name"); Assert.IsTrue(utEmptiedBucket.IsEmpty, "Retrieved emptied bucket is not empty"); Assert.IsFalse(utEmptiedBucket.IsFull, "Retrieved emptied bucket is full"); Assert.AreEqual(utNewBucket.Capacity, utNewBucketFromBuffer.Capacity, "Retrieved new bucket from buffer has different capacity"); Assert.AreEqual(utNewBucket.CurrentFill, utNewBucketFromBuffer.CurrentFill, "Retrieved new bucket from buffer has wrong current fill"); Assert.AreEqual(utNewBucket.Name, utNewBucketFromBuffer.Name, "Retrieved new bucket from buffer has wrong name"); Assert.IsTrue(utNewBucketFromBuffer.IsEmpty, "Retrieved new bucket from buffer is not empty"); Assert.IsFalse(utNewBucketFromBuffer.IsFull, "Retrieved new bucket from buffer is full"); Assert.AreEqual(utFullBucket.Capacity, utFullBucketFromBuffer.Capacity, "Retrieved Full bucket from buffer has different capacity"); Assert.AreEqual(utFullBucket.CurrentFill, utFullBucketFromBuffer.CurrentFill, "Retrieved Full bucket from buffer has wrong current fill"); Assert.AreEqual(utFullBucket.Name, utFullBucketFromBuffer.Name, "Retrieved Full bucket from buffer has wrong name"); Assert.IsFalse(utFullBucketFromBuffer.IsEmpty, "Retrieved Full bucket from buffer is empty"); Assert.IsTrue(utFullBucketFromBuffer.IsFull, "Retrieved Full bucket from buffer is not full"); Assert.AreEqual(utTransBucket.Capacity, utTransBucketFromBuffer.Capacity, "Retrieved Transferred bucket from buffer has different capacity"); Assert.AreEqual(utTransBucket.CurrentFill, utTransBucketFromBuffer.CurrentFill, "Retrieved Transferred bucket from buffer has wrong current fill"); Assert.AreEqual(utTransBucket.Name, utTransBucketFromBuffer.Name, "Retrieved Transferred bucket from buffer has wrong name"); Assert.IsFalse(utTransBucketFromBuffer.IsEmpty, "Retrieved Transferred bucket from buffer is empty"); Assert.IsFalse(utTransBucketFromBuffer.IsFull, "Retrieved Transferred bucket from buffer is full"); Assert.AreEqual(utEmptiedBucket.Capacity, utEmptiedBucketFromBuffer.Capacity, "Retrieved Emptied bucket from buffer has different capacity"); Assert.AreEqual(utEmptiedBucket.CurrentFill, utEmptiedBucketFromBuffer.CurrentFill, "Retrieved Emptied bucket from buffer has wrong current fill"); Assert.AreEqual(utEmptiedBucket.Name, utEmptiedBucketFromBuffer.Name, "Retrieved Emptied bucket from buffer has wrong name"); Assert.IsTrue(utEmptiedBucketFromBuffer.IsEmpty, "Retrieved Emptied bucket from buffer is not empty"); Assert.IsFalse(utEmptiedBucketFromBuffer.IsFull, "Retrieved Emptied bucket from buffer is full"); Assert.AreEqual(toBufferOffset, fromBufferOffset, "Buffer offsets differ"); }
public void TestBucketEmpty() { // Arrange int bucketCapacity = 5; Bucket utBucket = new Bucket(bucketCapacity); Reservoire waterSource = new Reservoire(); // Act utBucket.Fill(waterSource); utBucket.Empty(waterSource); //Assert Assert.AreEqual(0, utBucket.CurrentFill, "Emptied the Bucket but CurrentFill = " + utBucket.CurrentFill); Assert.AreNotEqual(bucketCapacity, utBucket.CurrentFill, "Emptied the bucket but it still has CurrentFill as test capacity"); Assert.AreNotEqual(utBucket.CurrentFill, utBucket.Capacity, "Emptied the bucket but it is reporting CurrentFill == Capacity"); Assert.IsTrue(utBucket.IsEmpty, "Emptied the bucket but reporting it is not empty"); Assert.IsFalse(utBucket.IsFull, "Emptied the bucket but it is reporting it is full"); }
public void TestReservoirePutWaterGreaterThanIntMax() { // Arrange int putAmount = 1, wayBig = int.MaxValue; Reservoire utReservoire = new Reservoire(); // Act utReservoire.PutWater(putAmount); int putVolume = utReservoire.VolumeThrownOut; try { utReservoire.PutWater(wayBig); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "ArgumentOutOfRangeException didn't report 'amount' parameter"); } catch (Exception ex) { Assert.Fail("PutWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when VolumeThrownOut == " + putVolume + " && put amount == " + wayBig); } Assert.IsTrue(CaughtEx, "PutWater did not throw ArgumentOutOfRangeException when VolumeThrownOut == " + putVolume + " && put amount == " + wayBig); }
public void TestReservoirePutWaterRandomLargeInts() { // Arrange int numIterations = Rand.Next(5000, 10000); for (int i = 0; i < numIterations; i++) { Reservoire utReservoire = new Reservoire(); // Act int randWayBig = Rand.Next(1000000, int.MaxValue - 1); utReservoire.PutWater(randWayBig); // Assert Assert.AreEqual(randWayBig, utReservoire.VolumeThrownOut, "VolumeThrownOut isn't random way big (" + randWayBig + ") when putting random way big (" + randWayBig + ") water [i=" + i + "/" + numIterations + "]"); } }
public static Reservoire GetFromBytes(byte[] data, int offset = 0) { Reservoire r = new Reservoire(); r.FromBytes(data, offset); return r; }
public void TestReservoirePutWaterZero() { // Arrange int zeroPut = 0; Reservoire utReservoire = new Reservoire(); // Act try { utReservoire.PutWater(zeroPut); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "ArgumentOutOfRangeException didn't report 'amount' parameter"); } catch (Exception ex) { Assert.Fail("PutWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when putting amount == 0"); } Assert.IsTrue(CaughtEx, "PutWater did not throw ArgumentOutOfRangeException when putting 0 water"); }
public int Fill(Reservoire source) { if (!this.IsFull) { int amount = this.Capacity - this.CurrentFill; this.CurrentFill += source.GetWater(this.Capacity - this.CurrentFill); return amount; } return 0; }
public void TestBucketFraming() { // Arrange Bucket sourceBucket = new Bucket(54, "SourceBucket"); Bucket otherBucket = new Bucket(4, "OtherBucket"); Encoding textEncoding = Encoding.UTF8; Bucket utNewBucket = new Bucket(); Bucket utFullBucket = new Bucket(); Bucket utTransBucket = new Bucket(); Bucket utEmptiedBucket = new Bucket(); Bucket utNewBucketFromMessage = new Bucket(); Bucket utFullBucketFromMessage = new Bucket(); Bucket utTransBucketFromMessage = new Bucket(); Bucket utEmptiedBucketFromMessage = new Bucket(); Reservoire waterSrc = new Reservoire(); // Act // Use ToList since IEnumerable/yield methods are lazy evaluated IEnumerable<Frame> utNewFrames = sourceBucket.GetFrames(textEncoding).ToList(); sourceBucket.Fill(waterSrc); IEnumerable<Frame> utFullFrames = sourceBucket.GetFrames(textEncoding).ToList(); sourceBucket.TransferTo(otherBucket); IEnumerable<Frame> utTransFrames = sourceBucket.GetFrames(textEncoding).ToList(); sourceBucket.Empty(waterSrc); IEnumerable<Frame> utEmptiedFrames = sourceBucket.GetFrames(textEncoding).ToList(); utNewBucket.FromFrames(utNewFrames, textEncoding: textEncoding); utFullBucket.FromFrames(utFullFrames, textEncoding: textEncoding); utTransBucket.FromFrames(utTransFrames, textEncoding: textEncoding); utEmptiedBucket.FromFrames(utEmptiedFrames, textEncoding: textEncoding); int numFrames = utNewFrames.Count() + utFullFrames.Count() + utTransFrames.Count() + utEmptiedFrames.Count(); List<Frame> msgFrames = new List<Frame>(numFrames); msgFrames.AddRange(utNewBucket.GetFrames(textEncoding)); msgFrames.AddRange(utFullBucket.GetFrames(textEncoding)); msgFrames.AddRange(utTransBucket.GetFrames(textEncoding)); msgFrames.AddRange(utEmptiedBucket.GetFrames(textEncoding)); int offset = 0; offset = utNewBucketFromMessage.FromFrames(msgFrames, offset, textEncoding); offset = utFullBucketFromMessage.FromFrames(msgFrames, offset, textEncoding); offset = utTransBucketFromMessage.FromFrames(msgFrames, offset, textEncoding); offset = utEmptiedBucketFromMessage.FromFrames(msgFrames, offset, textEncoding); // Assert Assert.AreEqual(sourceBucket.Capacity, utNewBucket.Capacity, "Retrieved new bucket has different capacity"); Assert.AreEqual(0, utNewBucket.CurrentFill, "Retrieved new bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utNewBucket.Name, "Retrieved new bucket has wrong name"); Assert.IsTrue(utNewBucket.IsEmpty, "Retrieved new bucket is not empty"); Assert.IsFalse(utNewBucket.IsFull, "Retrieved new bucket is full"); Assert.AreEqual(sourceBucket.Capacity, utFullBucket.Capacity, "Retrieved full bucket has different capacity"); Assert.AreEqual(sourceBucket.Capacity, utFullBucket.CurrentFill, "Retrieved full bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utFullBucket.Name, "Retrieved full bucket has wrong name"); Assert.IsFalse(utFullBucket.IsEmpty, "Retrieved full bucket is empty"); Assert.IsTrue(utFullBucket.IsFull, "Retrieved full bucket is not full"); Assert.AreEqual(sourceBucket.Capacity, utTransBucket.Capacity, "Retrieved transferred bucket has different capacity"); Assert.AreEqual(sourceBucket.Capacity - otherBucket.Capacity, utTransBucket.CurrentFill, "Retrieved transferred bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utTransBucket.Name, "Retrieved transferred bucket has wrong name"); Assert.IsFalse(utTransBucket.IsEmpty, "Retrieved transferred bucket is empty"); Assert.IsFalse(utTransBucket.IsFull, "Retrieved transferred bucket is full"); Assert.AreEqual(sourceBucket.Capacity, utEmptiedBucket.Capacity, "Retrieved emptied bucket has different capacity"); Assert.AreEqual(0, utEmptiedBucket.CurrentFill, "Retrieved emptied bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utEmptiedBucket.Name, "Retrieved emptied bucket has wrong name"); Assert.IsTrue(utEmptiedBucket.IsEmpty, "Retrieved emptied bucket is not empty"); Assert.IsFalse(utEmptiedBucket.IsFull, "Retrieved emptied bucket is full"); Assert.AreEqual(utNewBucket.Capacity, utNewBucketFromMessage.Capacity, "Retrieved new bucket from message has different capacity"); Assert.AreEqual(utNewBucket.CurrentFill, utNewBucketFromMessage.CurrentFill, "Retrieved new bucket from message has wrong current fill"); Assert.AreEqual(utNewBucket.Name, utNewBucketFromMessage.Name, "Retrieved new bucket from message has wrong name"); Assert.IsTrue(utNewBucketFromMessage.IsEmpty, "Retrieved new bucket from message is not empty"); Assert.IsFalse(utNewBucketFromMessage.IsFull, "Retrieved new bucket from message is full"); Assert.AreEqual(utFullBucket.Capacity, utFullBucketFromMessage.Capacity, "Retrieved Full bucket from message has different capacity"); Assert.AreEqual(utFullBucket.CurrentFill, utFullBucketFromMessage.CurrentFill, "Retrieved Full bucket from message has wrong current fill"); Assert.AreEqual(utFullBucket.Name, utFullBucketFromMessage.Name, "Retrieved Full bucket from message has wrong name"); Assert.IsFalse(utFullBucketFromMessage.IsEmpty, "Retrieved Full bucket from message is empty"); Assert.IsTrue(utFullBucketFromMessage.IsFull, "Retrieved Full bucket from message is not full"); Assert.AreEqual(utTransBucket.Capacity, utTransBucketFromMessage.Capacity, "Retrieved Transferred bucket from message has different capacity"); Assert.AreEqual(utTransBucket.CurrentFill, utTransBucketFromMessage.CurrentFill, "Retrieved Transferred bucket from message has wrong current fill"); Assert.AreEqual(utTransBucket.Name, utTransBucketFromMessage.Name, "Retrieved Transferred bucket from message has wrong name"); Assert.IsFalse(utTransBucketFromMessage.IsEmpty, "Retrieved Transferred bucket from message is empty"); Assert.IsFalse(utTransBucketFromMessage.IsFull, "Retrieved Transferred bucket from message is full"); Assert.AreEqual(utEmptiedBucket.Capacity, utEmptiedBucketFromMessage.Capacity, "Retrieved Emptied bucket from message has different capacity"); Assert.AreEqual(utEmptiedBucket.CurrentFill, utEmptiedBucketFromMessage.CurrentFill, "Retrieved Emptied bucket from message has wrong current fill"); Assert.AreEqual(utEmptiedBucket.Name, utEmptiedBucketFromMessage.Name, "Retrieved Emptied bucket from message has wrong name"); Assert.IsTrue(utEmptiedBucketFromMessage.IsEmpty, "Retrieved Emptied bucket from message is not empty"); Assert.IsFalse(utEmptiedBucketFromMessage.IsFull, "Retrieved Emptied bucket from message is full"); Assert.AreEqual(numFrames, offset, "Wrong number of frames after retrieving data"); }
public void TestBucketClone() { // Arrange Bucket sourceBucket = new Bucket(20, "SourceBucket"); Bucket otherBucket = new Bucket(8, "OtherBucket"); Reservoire waterSrc = new Reservoire(); Bucket utNewBucket, utFullBucket, utTransBucket, utEmptiedBucket; Bucket utNewBucketFromClone, utFullBucketFromClone, utTransBucketFromClone, utEmptiedBucketFromClone; // Act utNewBucket = sourceBucket.Clone() as Bucket; sourceBucket.Fill(waterSrc); utFullBucket = sourceBucket.Clone() as Bucket; sourceBucket.TransferTo(otherBucket); utTransBucket = sourceBucket.Clone() as Bucket; sourceBucket.Empty(waterSrc); utEmptiedBucket = sourceBucket.Clone() as Bucket; utNewBucketFromClone = utNewBucket.Clone() as Bucket; utFullBucketFromClone = utFullBucket.Clone() as Bucket; utTransBucketFromClone = utTransBucket.Clone() as Bucket; utEmptiedBucketFromClone = utEmptiedBucket.Clone() as Bucket; // Assert Assert.AreEqual(sourceBucket.Capacity, utNewBucket.Capacity, "Cloned new bucket has different capacity"); Assert.AreEqual(0, utNewBucket.CurrentFill, "Cloned new bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utNewBucket.Name, "Cloned new bucket has wrong name"); Assert.IsTrue(utNewBucket.IsEmpty, "Cloned new bucket is not empty"); Assert.IsFalse(utNewBucket.IsFull, "Cloned new bucket is full"); Assert.AreEqual(sourceBucket.Capacity, utFullBucket.Capacity, "Cloned full bucket has different capacity"); Assert.AreEqual(sourceBucket.Capacity, utFullBucket.CurrentFill, "Cloned full bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utFullBucket.Name, "Cloned full bucket has wrong name"); Assert.IsFalse(utFullBucket.IsEmpty, "Cloned full bucket is empty"); Assert.IsTrue(utFullBucket.IsFull, "Cloned full bucket is not full"); Assert.AreEqual(sourceBucket.Capacity, utTransBucket.Capacity, "Cloned transferred bucket has different capacity"); Assert.AreEqual(sourceBucket.Capacity - otherBucket.Capacity, utTransBucket.CurrentFill, "Cloned transferred bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utTransBucket.Name, "Cloned transferred bucket has wrong name"); Assert.IsFalse(utTransBucket.IsEmpty, "Cloned transferred bucket is empty"); Assert.IsFalse(utTransBucket.IsFull, "Cloned transferred bucket is full"); Assert.AreEqual(sourceBucket.Capacity, utEmptiedBucket.Capacity, "Cloned emptied bucket has different capacity"); Assert.AreEqual(0, utEmptiedBucket.CurrentFill, "Cloned emptied bucket has wrong current fill"); Assert.AreEqual(sourceBucket.Name, utEmptiedBucket.Name, "Cloned emptied bucket has wrong name"); Assert.IsTrue(utEmptiedBucket.IsEmpty, "Cloned emptied bucket is not empty"); Assert.IsFalse(utEmptiedBucket.IsFull, "Cloned emptied bucket is full"); Assert.AreEqual(utNewBucket.Capacity, utNewBucketFromClone.Capacity, "Cloned new bucket from Clone has different capacity"); Assert.AreEqual(utNewBucket.CurrentFill, utNewBucketFromClone.CurrentFill, "Cloned new bucket from Clone has wrong current fill"); Assert.AreEqual(utNewBucket.Name, utNewBucketFromClone.Name, "Cloned new bucket from Clone has wrong name"); Assert.IsTrue(utNewBucketFromClone.IsEmpty, "Cloned new bucket from Clone is not empty"); Assert.IsFalse(utNewBucketFromClone.IsFull, "Cloned new bucket from Clone is full"); Assert.AreEqual(utFullBucket.Capacity, utFullBucketFromClone.Capacity, "Cloned Full bucket from Clone has different capacity"); Assert.AreEqual(utFullBucket.CurrentFill, utFullBucketFromClone.CurrentFill, "Cloned Full bucket from Clone has wrong current fill"); Assert.AreEqual(utFullBucket.Name, utFullBucketFromClone.Name, "Cloned Full bucket from Clone has wrong name"); Assert.IsFalse(utFullBucketFromClone.IsEmpty, "Cloned Full bucket from Clone is empty"); Assert.IsTrue(utFullBucketFromClone.IsFull, "Cloned Full bucket from Clone is not full"); Assert.AreEqual(utTransBucket.Capacity, utTransBucketFromClone.Capacity, "Cloned Transferred bucket from Clone has different capacity"); Assert.AreEqual(utTransBucket.CurrentFill, utTransBucketFromClone.CurrentFill, "Cloned Transferred bucket from Clone has wrong current fill"); Assert.AreEqual(utTransBucket.Name, utTransBucketFromClone.Name, "Cloned Transferred bucket from Clone has wrong name"); Assert.IsFalse(utTransBucketFromClone.IsEmpty, "Cloned Transferred bucket from Clone is empty"); Assert.IsFalse(utTransBucketFromClone.IsFull, "Cloned Transferred bucket from Clone is full"); Assert.AreEqual(utEmptiedBucket.Capacity, utEmptiedBucketFromClone.Capacity, "Cloned Emptied bucket from Clone has different capacity"); Assert.AreEqual(utEmptiedBucket.CurrentFill, utEmptiedBucketFromClone.CurrentFill, "Cloned Emptied bucket from Clone has wrong current fill"); Assert.AreEqual(utEmptiedBucket.Name, utEmptiedBucketFromClone.Name, "Cloned Emptied bucket from Clone has wrong name"); Assert.IsTrue(utEmptiedBucketFromClone.IsEmpty, "Cloned Emptied bucket from Clone is not empty"); Assert.IsFalse(utEmptiedBucketFromClone.IsFull, "Cloned Emptied bucket from Clone is full"); // Act 2 // Assert 2 // Act 3 // Assert 3 }
public ProblemState(Reservoire source, params Bucket[] buckets) { BucketState = buckets.Select(b => b.Clone() as Bucket).ToList(); SourceState = source.CurrentState; }
public void TestBucketTransferBigToSmall() { // Arrange int bucketCapacityBig = 5, bucketCapacitySmall = 3; int bucketDifference = Math.Abs(bucketCapacityBig - bucketCapacitySmall); Bucket utBucketBig = new Bucket(bucketCapacityBig), utBucketSmall = new Bucket(bucketCapacitySmall); Reservoire waterSource = new Reservoire(); // Act utBucketBig.Fill(waterSource); Assert.IsTrue(utBucketSmall.IsEmpty, "Something went wrong is Arrange as small bucket is not empty"); utBucketBig.TransferTo(utBucketSmall); //Assert Assert.AreEqual(bucketCapacitySmall, utBucketSmall.CurrentFill, "Transferred from big to small but small bucket not at test capacity"); Assert.AreEqual(utBucketSmall.Capacity, utBucketSmall.CurrentFill, "Transferred from big to small but small bucket not at reported capacity"); Assert.AreNotEqual(0, utBucketSmall.CurrentFill, "Transferred big to small but small reporting CurrentFill == 0"); Assert.IsTrue(utBucketSmall.IsFull, "Transferred big to small but small reporting is not full"); Assert.IsFalse(utBucketSmall.IsEmpty, "Transferred big to small but small reporting it is empty"); Assert.AreNotEqual(0, utBucketBig.CurrentFill, "Transferred from big to small but big reporting CurrentFill == 0"); Assert.AreEqual(bucketDifference, utBucketBig.CurrentFill, "Transferred from big to small but big CurrentFill != bucketDifference(" + bucketDifference + ")"); Assert.AreNotEqual(bucketCapacityBig, utBucketBig.CurrentFill, "Transferred from big to small but big has CurrentFill == test capacity big"); Assert.AreNotEqual(utBucketBig.CurrentFill, utBucketBig.Capacity, "Transferred from big to small but big has CurrentFill == Capacity"); Assert.IsFalse(utBucketBig.IsFull, "Transferred big to small but big reporting full"); Assert.IsFalse(utBucketBig.IsEmpty, "Transferred from big to small but big reporting is empty"); }
public void TestReservoireGetWaterRandomNegatives() { // Arrange int numIterations = Rand.Next(5000, 10000); Reservoire utReservoire = new Reservoire(); for (int i = 0; i < numIterations; i++) { int noGet = 0, minusAmount = Rand.Next(int.MinValue + 1, -2); CaughtEx = false; // Act try { noGet = utReservoire.GetWater(minusAmount); } // Assert catch (ArgumentOutOfRangeException aore) { CaughtEx = true; Assert.AreEqual("amount", aore.ParamName, "ArgumentOutOfRangeException didn't report 'amount' parameter [i=" + i + "/" + numIterations + "]"); Assert.AreEqual(0, noGet, "Reservoire GetWater returned value == " + noGet + " even though ArgumentOutOfRangeException was thrown for getting amount == " + minusAmount + " [i=" + i + "/" + numIterations + "]"); } catch (Exception ex) { Assert.Fail("GetWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when getting amount == " + minusAmount + " [i=" + i + "/" + numIterations + "]"); } Assert.IsTrue(CaughtEx, "GetWater did not throw ArgumentOutOfRangeException when getting " + minusAmount + " water [i=" + i + "/" + numIterations + "]"); } }
public void TestBucketFill() { // Arrange int bucketCapacity = 5; Bucket utBucket = new Bucket(bucketCapacity); Reservoire waterSource = new Reservoire(); // Act utBucket.Fill(waterSource); //Assert Assert.AreEqual(bucketCapacity, utBucket.CurrentFill, "Filled the Bucket but it is not at Capacity"); Assert.AreNotEqual(0, utBucket.CurrentFill, "Filled the bucket but it is reporting 0 CurrentFill"); Assert.AreEqual(utBucket.CurrentFill, utBucket.Capacity, "Filled bucket but CurrentFill not equal to Capacity"); Assert.IsTrue(utBucket.IsFull, "Filled bucket to capacity but it is reporting not full"); Assert.IsFalse(utBucket.IsEmpty, "Filled bucket to capacity but it is reporting empty"); }
public void TestReservoireGetWaterZero() { // Arrange int zeroGet = 0; Reservoire utReservoire = new Reservoire(); // Act int noGet = -1; try { noGet = utReservoire.GetWater(zeroGet); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "ArgumentOutOfRangeException didn't report 'amount' parameter"); Assert.AreEqual(-1, noGet, "Reservoire GetWater returned value == " + noGet + " even though ArgumentOutOfRangeException was thrown for getting amount == 0"); } catch (Exception ex) { Assert.Fail("GetWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when getting amount == 0"); } Assert.IsTrue(CaughtEx, "GetWater did not throw ArgumentOutOfRangeException when getting 0 water"); }
public void TestReservoireCurrentState() { // Arrange int numAmounts = Rand.Next(5000, 10000), getIterations = 0, putIterations = 0; int[] getAmounts = new int[numAmounts], gotTotals = new int[numAmounts], putAmounts = new int[numAmounts], putTotals = new int[numAmounts]; int getAmount = 0; long longGetTotal = 0; for (int a = 0; a < numAmounts; a++) { getAmount = Rand.Next(1, 30000); longGetTotal += getAmount; if ((longGetTotal >> 32) > 0) { getIterations = a; break; } getAmounts[a] = getAmount; gotTotals[a] = (int)longGetTotal; } if (getIterations == 0) { getIterations = numAmounts; getAmount = Rand.Next(int.MaxValue - gotTotals[gotTotals.Length - 1] + 2, int.MaxValue - 1); longGetTotal += getAmount; } int putAmount = 0; long longPutTotal = 0; for (int a = 0; a < numAmounts; a++) { putAmount = Rand.Next(1, 30000); longPutTotal += putAmount; if ((longPutTotal >> 32) > 0) { putIterations = a; break; } putAmounts[a] = putAmount; putTotals[a] = (int)longPutTotal; } if (putIterations == 0) { putIterations = numAmounts; putAmount = Rand.Next(int.MaxValue - putTotals[putTotals.Length - 1] + 2, int.MaxValue - 1); longPutTotal += putAmount; } Reservoire utReservoire = new Reservoire(), utReservoireFromState = null; ReservoireState utStateInitial = null, utState = null; // Act utStateInitial = utReservoire.CurrentState; utReservoireFromState = new Reservoire(utStateInitial); // Assert Assert.AreEqual(0, utStateInitial.VolumeUsed, "CurrentState from empty constructed initial Reservoire VolumeUsed not equal to 0"); Assert.AreEqual(0, utStateInitial.VolumeThrownOut, "CurrentState from empty constructed initial Reservoire VolumeThrownOut not equal to 0"); Assert.AreEqual(0, utReservoireFromState.VolumeUsed, "ReservoireState constructor from empty constructed initial Reservoire VolumeUsed not equal to 0"); Assert.AreEqual(0, utReservoireFromState.VolumeThrownOut, "ReservoireState constructor from empty constructed initial Reservoire VolumeThrownOut not equal to 0"); // Arrange int initIterations = Math.Min(getIterations, putIterations); int finishIterations = Math.Max(getIterations, putIterations) - initIterations; for (int i = 0; i < initIterations; i++) { // Arrange utState = null; utReservoireFromState = null; // Act utReservoire.GetWater(getAmounts[i]); utReservoire.PutWater(putAmounts[i]); utState = utReservoire.CurrentState; utReservoireFromState = new Reservoire(utState); // Assert Assert.AreEqual(gotTotals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(putTotals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.IsNotNull(utState, "CurrentState returned null [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeUsed, utState.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeThrownOut, utState.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.IsNotNull(utReservoireFromState, "Constructing a new Reservoire from ReservoireState returned null (should be impossible with new call) [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeUsed, utReservoireFromState.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeThrownOut, utReservoireFromState.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); } if (initIterations < getIterations) { for (int i = initIterations; i < finishIterations; i++) { // Arrange utState = null; utReservoireFromState = null; // Act utReservoire.GetWater(getAmounts[i]); utState = utReservoire.CurrentState; utReservoireFromState = new Reservoire(utState); // Assert Assert.AreEqual(gotTotals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(putTotals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.IsNotNull(utState, "CurrentState returned null"); Assert.AreEqual(utReservoire.VolumeUsed, utState.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeThrownOut, utState.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.IsNotNull(utReservoireFromState, "Constructing a new Reservoire from ReservoireState returned null (should be impossible with new call)"); Assert.AreEqual(utReservoire.VolumeUsed, utReservoireFromState.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeThrownOut, utReservoireFromState.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); } } else if (initIterations < putIterations) { for (int i = initIterations; i < finishIterations; i++) { // Arrange utState = null; utReservoireFromState = null; // Act utReservoire.PutWater(putAmounts[i]); utState = utReservoire.CurrentState; utReservoireFromState = new Reservoire(utState); // Assert Assert.AreEqual(gotTotals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(putTotals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.IsNotNull(utState, "CurrentState returned null"); Assert.AreEqual(utReservoire.VolumeUsed, utState.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeThrownOut, utState.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.IsNotNull(utReservoireFromState, "Constructing a new Reservoire from ReservoireState returned null (should be impossible with new call)"); Assert.AreEqual(utReservoire.VolumeUsed, utReservoireFromState.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(utReservoire.VolumeThrownOut, utReservoireFromState.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); } } }
public void TestReservoirePutWaterIntMax() { // Arrange int wayBig = int.MaxValue; Reservoire utReservoire = new Reservoire(); // Act utReservoire.PutWater(wayBig); // Assert Assert.AreEqual(wayBig, utReservoire.VolumeThrownOut, "VolumeThrownOut isn't int.MaxValue when putting int.MaxValue water"); }
public void TestReservoireGetThenPutWater() { // Arrange int numAmounts = Rand.Next(5000, 10000), getIterations = 0, putIterations = 0; int[] getAmounts = new int[numAmounts], gotTotals = new int[numAmounts], putAmounts = new int[numAmounts], putTotals = new int[numAmounts]; int getAmount = 0; long longGetTotal = 0; for (int a = 0; a < numAmounts; a++) { getAmount = Rand.Next(1, 30000); longGetTotal += getAmount; if ((longGetTotal >> 32) > 0) { getIterations = a; break; } getAmounts[a] = getAmount; gotTotals[a] = (int)longGetTotal; } if (getIterations == 0) { getIterations = numAmounts; getAmount = Rand.Next(int.MaxValue - gotTotals[gotTotals.Length - 1] + 2, int.MaxValue - 1); longGetTotal += getAmount; } int putAmount = 0; long longPutTotal = 0; for (int a = 0; a < numAmounts; a++) { putAmount = Rand.Next(1, 30000); longPutTotal += putAmount; if ((longPutTotal >> 32) > 0) { putIterations = a; break; } putAmounts[a] = putAmount; putTotals[a] = (int)longPutTotal; } if (putIterations == 0) { putIterations = numAmounts; putAmount = Rand.Next(int.MaxValue - putTotals[putTotals.Length - 1] + 2, int.MaxValue - 1); longPutTotal += putAmount; } Reservoire utReservoire = new Reservoire(); int amountGotten = 0; int initIterations = Math.Min(getIterations, putIterations); int finishIterations = Math.Max(getIterations, putIterations) - initIterations; for (int i = 0; i < initIterations; i++) { // Act amountGotten = utReservoire.GetWater(getAmounts[i]); utReservoire.PutWater(putAmounts[i]); // Assert Assert.AreEqual(getAmounts[i], amountGotten, "GetWater returned different amount that requested [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(gotTotals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); Assert.AreEqual(putTotals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + initIterations + ":" + finishIterations + "]"); } if (initIterations < getIterations) { for (int i = initIterations; i < finishIterations; i++) { // Act amountGotten = utReservoire.GetWater(getAmounts[i]); // Assert Assert.AreEqual(getAmounts[i], amountGotten, "GetWater returned different amount that requested [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(gotTotals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(putTotals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); } } else if (initIterations < putIterations) { for (int i = initIterations; i < finishIterations; i++) { // Act utReservoire.PutWater(putAmounts[i]); // Assert Assert.AreEqual(gotTotals[i], utReservoire.VolumeUsed, "Current VolumeUsed not equal to expected total [i=" + i + "/" + finishIterations + "]"); Assert.AreEqual(putTotals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + finishIterations + "]"); } } int noGet = -1; try { // Act noGet = utReservoire.GetWater(getAmount); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "GetWater ArgumentOutOfRangeException didn't report 'amount' parameter"); Assert.AreEqual(-1, noGet, "Reservoire GetWater returned value == " + noGet + " even though ArgumentOutOfRangeException was thrown for getting too much water"); } catch (Exception ex) { Assert.Fail("GetWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when VolumeUsed == " + gotTotals[getIterations - 1] + " && get amount == " + getAmount); } Assert.IsTrue(CaughtEx, "GetWater did not throw ArgumentOutOfRangeException when VolumeUsed == " + gotTotals[getIterations - 1] + " && get amount == " + getAmount); // Arrange CaughtEx = false; try { // Act utReservoire.PutWater(putAmount); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "PutWater ArgumentOutOfRangeException didn't report 'amount' parameter"); } catch (Exception ex) { Assert.Fail("PutWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when VolumeThrownOut == " + putTotals[putIterations - 1] + " && put amount == " + putAmount); } Assert.IsTrue(CaughtEx, "PutWater did not throw ArgumentOutOfRangeException when VolumeUsed == " + putTotals[putIterations - 1] + " && put amount == " + putAmount); }
public void TestReservoirePutWaterRandomNegatives() { // Arrange int numIterations = Rand.Next(5000, 10000), lowest = int.MinValue + 1; Reservoire utReservoire = new Reservoire(); for (int i = 0; i < numIterations; i++) { CaughtEx = false; int minusAmount = Rand.Next(lowest, -2); // Act try { utReservoire.PutWater(minusAmount); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "ArgumentOutOfRangeException didn't report 'amount' parameter [i=" + i + "/" + numIterations + "]"); } catch (Exception ex) { Assert.Fail("PutWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when putting amount == " + minusAmount + " [i=" + i + "/" + numIterations + "]"); } Assert.IsTrue(CaughtEx, "PutWater did not throw ArgumentOutOfRangeException when putting " + minusAmount + " water [i=" + i + "/" + numIterations + "]"); } }
public void TestBucketSerialization() { // Arrange Bucket utBucket = new Bucket(88, "utBucket"); Bucket otherBucket = new Bucket(32, "other Bucket"); Reservoire waterSource = new Reservoire(); utBucket.Fill(waterSource); utBucket.TransferTo(otherBucket); using (MemoryStream ms = new MemoryStream()) { BinaryFormatter formatter = new BinaryFormatter(); try { // Act - Serialize formatter.Serialize(ms, utBucket); // Assert - Serialize } catch (Exception ex) { Assert.Fail("Serialization failed for Bucket with message: " + ex.Message); } ms.Position = 0; try { // Act - Deserialize Bucket deserializedBucket = (Bucket)formatter.Deserialize(ms); // Assert - Deserialize Assert.IsTrue(utBucket.Equals(deserializedBucket), "Deserialized Bucket not equal to utBucket that was Serialized"); } catch (Exception ex) { Assert.Fail("Deserialization failed for Bucket with message: " + ex.Message); } } }
public void TestReservoireBasicPut() { // Arrange int numAmounts = Rand.Next(5000, 10000), iterations = 0; int[] amounts = new int[numAmounts], totals = new int[numAmounts]; int amount = 0; long longTotal = 0; for (int a = 0; a < numAmounts; a++) { amount = Rand.Next(1, 30000); longTotal += amount; if ((longTotal >> 32) > 0) { iterations = a; break; } amounts[a] = amount; totals[a] = (int)longTotal; } if (iterations == 0) { iterations = numAmounts; amount = Rand.Next(int.MaxValue - totals[totals.Length - 1] + 2, int.MaxValue - 1); longTotal += amount; } Reservoire utReservoire = new Reservoire(); for (int i = 0; i < iterations; i++) { // Act utReservoire.PutWater(amounts[i]); // Assert Assert.AreEqual(totals[i], utReservoire.VolumeThrownOut, "Current VolumeThrownOut not equal to expected total [i=" + i + "/" + iterations + "]"); } try { // Act utReservoire.PutWater(amount); } // Assert catch (ArgumentOutOfRangeException ex) { CaughtEx = true; Assert.AreEqual("amount", ex.ParamName, "PutWater ArgumentOutOfRangeException didn't report 'amount' parameter"); } catch (Exception ex) { Assert.Fail("PutWater threw a different Exception (" + ex.GetType().Name + ") instead of ArgumentOutOfRangeException when VolumeThrownOut == " + totals[iterations - 1] + " && put amount == " + amount); } Assert.IsTrue(CaughtEx, "PutWater did not throw ArgumentOutOfRangeException when VolumeThrownOut == " + totals[iterations - 1] + " && put amount == " + amount); }
public void TestReservoireSuccessfulConstruction() { // Arrange Reservoire utReservoire = null; ReservoireState newState = new ReservoireState(0, 0), testState = null; try { // Act utReservoire = new Reservoire(); testState = utReservoire.CurrentState; } catch (Exception ex) { Assert.Fail("Reservoire constructor threw an Exception - " + ex.GetType().Name + ": " + ex.Message); } // Assert Assert.IsNotNull(utReservoire, "Constructor for Reservoire returned null"); Assert.AreEqual(0, utReservoire.VolumeUsed, "New Reservoire has VolumeUsed != 0"); Assert.AreEqual(0, utReservoire.VolumeThrownOut, "New Reservoire has VolumeThrownOut != 0"); Assert.AreEqual(newState.VolumeUsed, testState.VolumeUsed, "Test state VolumeUsed != New state VolumeUsed"); Assert.AreEqual(newState.VolumeThrownOut, testState.VolumeThrownOut, "Test state VolumeThrownOut != New state VolumeThrownOut"); }