ArrayTests.qs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.


namespace Microsoft.Quantum.Tests {
 open Microsoft.Quantum.Canon;
 open Microsoft.Quantum.Primitive;

 function ZipTest() : () {
 let left = [1; 2; 101];
 let right = [PauliY; PauliI];
 let zipped = Zip(left, right);

 let (leftActual1, rightActual1) = zipped[0];
 if (leftActual1 != 1 || rightActual1 != PauliY) {
 fail $"Expected (1, PauliY), got ({leftActual1}, {rightActual1}).";
 }

 let (leftActual2, rightActual2) = zipped[1];
 if (leftActual2 != 2 || rightActual2 != PauliI) {
 fail $"Expected (2, PauliI), got ({leftActual2}, {rightActual2}).";
 }
 }

 function LookupTest() : () {
 let array = [1; 12; 71; 103];
 let fn = LookupFunction(array);
 AssertIntEqual(fn(0), 1, "fn(0) did not return array[0]");
 // Make sure we can call in random order!
 AssertIntEqual(fn(3), 103, "fn(3) did not return array[3]");
 AssertIntEqual(fn(2), 71, "fn(2) did not return array[2]");
 AssertIntEqual(fn(1), 12, "fn(1) did not return array[1]");
 }

 function ConstantArrayTestHelper(x : Int) : Int {
 return x * x;
 }

 function ConstantArrayTest() : () {
 let dblArray = ConstantArray(71, 2.17);
 AssertIntEqual(Length(dblArray), 71, "ConstantArray(Int, Double) had the wrong length.");
 let ignore = Map(AssertAlmostEqual(_, 2.17), dblArray);
 // Stress test by making an array of Int -> Int.
 let fnArray = ConstantArray(7, ConstantArrayTestHelper);
 AssertIntEqual(Length(fnArray), 7, "ConstantArray(Int, Int -> Int) had the wrong length.");
 AssertIntEqual((fnArray[3])(7), 49, "ConstantArray(Int, Int -> Int) had the wrong value.");
 }

	function SubarrayTest() : () {
		let array0 = [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10];
		let subarrayOdd = Subarray([1; 3; 5; 7; 9], array0);
		let subarrayEven = Subarray([0; 2; 4; 6; 8; 10], array0);
		AssertBoolEqual(ForAll(IsEven, subarrayEven), true, "the even elements of [1..10] were not correctly sliced.");
		AssertBoolEqual(ForAny(IsEven, subarrayOdd), false, "the odd elements of [1..10] were not correctly sliced.");

 let array1 = [10; 11; 12; 13];
 Ignore(Map(AssertIntEqual(_, _, "Subarray failed: subpermutation case."), Zip([12; 11], Subarray([2; 1], array1))));
	}

	function FilterTest() : () {
		let array = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10];
		let evenArray = Filter(IsEven, array);
		AssertBoolEqual(ForAll(IsEven, evenArray), true, "the even elements of [1..10] were not correctly filtered.");
	}

 function ReverseTest() : () {
 let array = [1; 2; 3];
 Ignore(Map(AssertIntEqual(_, _, "Reverse failed."), Zip([3; 2; 1], Reverse(array))));
 }

 function ExcludeTest() : () {
 let array = [10; 11; 12; 13; 14; 15];
 Ignore(Map(AssertIntEqual(_, _, "Exclude failed."), Zip([10; 11; 13; 14], Exclude([2; 5], array))));
 }

 function PadTest() : () {
 mutable arrayTestCase = [(-5,2,[10; 11; 12],[10; 11; 12; 2; 2]);(5,2,[10; 11; 12],[2; 2; 10; 11; 12]);(-3,-2,[10; 11; 12],[10; 11; 12])];
 for(idxTest in 0..Length(arrayTestCase)-1){
 let (nElementsTotal, defaultElement, inputArray, outputArray) = arrayTestCase[idxTest];
 let paddedArray = Pad(nElementsTotal, defaultElement, inputArray);
 Ignore(Map(AssertIntEqual(_, _, "Pad failed."), Zip(outputArray, paddedArray)));

 }
 
 }

}