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;
 }
Example #2
0
        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
        }