Passed all tests in MTMathListTest and MTMathListbuilderTest suites.
This commit is contained in:
Michael Griebling
@@ -139,7 +139,7 @@ final class MTMathListTests: XCTestCase {
|
||||
let list = MTMathList()
|
||||
var atom : MTMathAtom? = nil
|
||||
list.add(atom)
|
||||
atom = MTMathAtom.atom(withType: .boundary, value: "")
|
||||
atom = MTMathAtom(type: .boundary, value: "")
|
||||
XCTExpectFailure("Test adding an illegal atom", options:options) {
|
||||
XCTAssertThrowsError(list.add(atom))
|
||||
}
|
||||
@@ -169,7 +169,7 @@ final class MTMathListTests: XCTestCase {
|
||||
let list = MTMathList()
|
||||
var atom : MTMathAtom? = nil
|
||||
list.insert(atom, at: 0)
|
||||
atom = MTMathAtom.atom(withType: .boundary, value:"")
|
||||
atom = MTMathAtom(type: .boundary, value:"")
|
||||
XCTExpectFailure("Test adding an illegal atom", options:options) {
|
||||
XCTAssertThrowsError(list.insert(atom, at:0))
|
||||
}
|
||||
@@ -262,356 +262,363 @@ final class MTMathListTests: XCTestCase {
|
||||
// func MTAssertNotEqual(test, expression1, expression2, ...) \
|
||||
// _XCTPrimitiveAssertNotEqual(test, expression1, @#expression1, expression2, @#expression2, __VA_ARGS__)
|
||||
|
||||
// func checkAtomCopy(_ copy:MTMathAtom, original:MTMathAtom, forTest test:XCTestCase?) throws {
|
||||
// MTAssertEqual(test, copy.type, original.type);
|
||||
// MTAssertEqual(test, copy.nucleus, original.nucleus);
|
||||
// // Deep copy
|
||||
// MTAssertNotEqual(test, copy, original);
|
||||
// }
|
||||
//
|
||||
// func checkListCopy(_ copy:MTMathList, original:MTMathList, forTest test:XCTestCase?) throws {
|
||||
// MTAssertEqual(test, copy.atoms.count, original.atoms.count)
|
||||
// for (i, copyAtom) in copy.atoms.enumerated() {
|
||||
// let origAtom = original.atoms[i];
|
||||
// try self.checkAtomCopy(copyAtom, original:origAtom, forTest:test)
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// func testCopy() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let list2 = list.copy()
|
||||
// checkListCopy(list2, original:list, forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testAtomInit() throws {
|
||||
// var atom = MTMathAtom.atom(withType: .open, value:"(")
|
||||
// XCTAssertEqual(atom.nucleus, "(");
|
||||
// XCTAssertEqual(atom.type, .open);
|
||||
//
|
||||
// atom = MTMathAtom.atom(withType: .radical, value:"(")
|
||||
// XCTAssertEqual(atom.nucleus, "");
|
||||
// XCTAssertEqual(atom.type, .radical);
|
||||
// }
|
||||
//
|
||||
// func testAtomScripts() throws {
|
||||
// var atom = MTMathAtom.atom(withType: .open, value:"(")
|
||||
// XCTAssertTrue(atom.isScriptAllowed())
|
||||
// atom.subScript = MTMathList()
|
||||
// XCTAssertNotNil(atom.subScript);
|
||||
// atom.superScript = MTMathList()
|
||||
// XCTAssertNotNil(atom.superScript);
|
||||
//
|
||||
// atom = MTMathAtom.atom(withType: .boundary, value:"(")
|
||||
// XCTAssertFalse(atom.isScriptAllowed());
|
||||
// // Can set to nil
|
||||
// atom.subScript = nil;
|
||||
// XCTAssertNil(atom.subScript);
|
||||
// atom.superScript = nil;
|
||||
// XCTAssertNil(atom.superScript);
|
||||
// // Can't set to value
|
||||
// let list = MTMathList()
|
||||
// XCTAssertThrowsError(atom.subScript = list);
|
||||
// XCTAssertThrowsError(atom.superScript = list);
|
||||
// }
|
||||
//
|
||||
// func testAtomCopy() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom1 = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom1)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let list2 = MTMathList()
|
||||
// list2.add(atom3)
|
||||
// list2.add(atom2)
|
||||
//
|
||||
// let atom = MTMathAtom.atom(withType: .open, value:"(")
|
||||
// atom.subScript = list;
|
||||
// atom.superScript = list2;
|
||||
// let copy = atom.copy()
|
||||
//
|
||||
// checkAtomCopy(copy, original:atom, forTest:self)
|
||||
// checkListCopy(copy.superScript, original:atom.superScript, forTest:self)
|
||||
// checkListCopy(copy.subScript, original:atom.subScript, forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testCopyFraction() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let list2 = MTMathList()
|
||||
// list2.add(atom3)
|
||||
// list2.add(atom2)
|
||||
//
|
||||
// let frac = MTFraction(hasRule: false)
|
||||
// XCTAssertEqual(frac.type, .fraction);
|
||||
// frac.numerator = list;
|
||||
// frac.denominator = list2;
|
||||
// frac.leftDelimiter = "a";
|
||||
// frac.rightDelimiter = "b";
|
||||
//
|
||||
// let copy = frac.copy() as! MTFraction
|
||||
// try checkAtomCopy(copy, original:frac, forTest:self)
|
||||
// checkListCopy(copy.numerator, original:frac.numerator, forTest:self)
|
||||
// checkListCopy(copy.denominator, original:frac.denominator, forTest:self)
|
||||
// XCTAssertFalse(copy.hasRule)
|
||||
// XCTAssertEqual(copy.leftDelimiter, "a");
|
||||
// XCTAssertEqual(copy.rightDelimiter, "b");
|
||||
// }
|
||||
//
|
||||
// func testCopyRadical() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let list2 = MTMathList()
|
||||
// list2.add(atom3)
|
||||
// list2.add(atom2)
|
||||
//
|
||||
// let rad = [[MTRadical alloc] init)
|
||||
// XCTAssertEqual(rad.type, kMTMathAtomRadical);
|
||||
// rad.radicand = list;
|
||||
// rad.degree = list2;
|
||||
//
|
||||
// let copy = [rad copy)
|
||||
// checkAtomCopy(copy original:rad forTest:self)
|
||||
// checkListCopy(copy.radicand original:rad.radicand forTest:self)
|
||||
// checkListCopy(copy.degree original:rad.degree forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testCopyLargeOperator() throws {
|
||||
// let lg = [[MTLargeOperator alloc] initWithValue:"lim" limits:true)
|
||||
// XCTAssertEqual(lg.type, kMTMathAtomLargeOperator);
|
||||
// XCTAssertTrue(lg.limits);
|
||||
//
|
||||
// let copy = [lg copy)
|
||||
// checkAtomCopy(copy original:lg forTest:self)
|
||||
// XCTAssertEqual(copy.limits, lg.limits);
|
||||
// }
|
||||
// func testCopyInner() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let inner = MTInner()
|
||||
// inner.innerList = list;
|
||||
// inner.leftBoundary = MTMathAtom.atom(withType: .boundary, value: "(")
|
||||
// inner.rightBoundary = MTMathAtom.atom(withType: .boundary, value:")")
|
||||
// XCTAssertEqual(inner.type, .inner);
|
||||
//
|
||||
// let copy = [inner copy)
|
||||
// checkAtomCopy(copy original:inner forTest:self)
|
||||
// checkListCopy(copy.innerList original:inner.innerList forTest:self)
|
||||
// checkAtomCopy(copy.leftBoundary original:inner.leftBoundary forTest:self)
|
||||
// checkAtomCopy(copy.rightBoundary original:inner.rightBoundary forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testSetInnerBoundary() throws {
|
||||
// let inner = MTInner()
|
||||
//
|
||||
// // Can set non-nil
|
||||
// inner.leftBoundary = MTMathAtom.atom(withType: .boundary, value:"(")
|
||||
// inner.rightBoundary = MTMathAtom.atom(withType: .boundary, value:")")
|
||||
// XCTAssertNotNil(inner.leftBoundary);
|
||||
// XCTAssertNotNil(inner.rightBoundary);
|
||||
// // Can set nil
|
||||
// inner.leftBoundary = nil;
|
||||
// inner.rightBoundary = nil;
|
||||
// XCTAssertNil(inner.leftBoundary);
|
||||
// XCTAssertNil(inner.rightBoundary);
|
||||
// // Can't set non boundary
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// XCTAssertThrowsError(inner.leftBoundary = atom);
|
||||
// XCTAssertThrowsError(inner.rightBoundary = atom);
|
||||
// }
|
||||
//
|
||||
// func testCopyOverline() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let over = MTOverLine()
|
||||
// XCTAssertEqual(over.type, .overline);
|
||||
// over.innerList = list;
|
||||
//
|
||||
// let copy = [over copy)
|
||||
// checkAtomCopy(copy original:over forTest:self)
|
||||
// checkListCopy(copy.innerList original:over.innerList forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testCopyUnderline() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let under = MTUnderLine()
|
||||
// XCTAssertEqual(under.type, .underline);
|
||||
// under.innerList = list;
|
||||
//
|
||||
// let copy = [under copy)
|
||||
// checkAtomCopy(copy, original:under, forTest:self)
|
||||
// checkListCopy(copy.innerList original:under.innerList forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testCopyAcccent() throws {
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let accent = [[MTAccent alloc] initWithValue:"^")
|
||||
// XCTAssertEqual(accent.type, kMTMathAtomAccent);
|
||||
// accent.innerList = list;
|
||||
//
|
||||
// let copy = [accent copy)
|
||||
// checkAtomCopy(copy original:accent forTest:self)
|
||||
// checkListCopy(copy.innerList original:accent.innerList forTest:self)
|
||||
// }
|
||||
//
|
||||
// func testCopySpace() throws {
|
||||
// let space = MTMathSpace(space: 3)
|
||||
// XCTAssertEqual(space.type, .space);
|
||||
//
|
||||
// let copy = [space copy)
|
||||
// checkAtomCopy(copy, original:space, forTest:self)
|
||||
// XCTAssertEqual(space.space, copy.space);
|
||||
// }
|
||||
//
|
||||
// func testCopyStyle() throws {
|
||||
// let style = MTMathStyle(style: .script)
|
||||
// XCTAssertEqual(style.type, .style);
|
||||
//
|
||||
// let copy = style.copy() as! MTMathStyle
|
||||
// checkAtomCopy(copy, original:style, forTest:self)
|
||||
// XCTAssertEqual(style.style, copy.style);
|
||||
// }
|
||||
//
|
||||
// func testCreateMathTable() throws {
|
||||
// let table = MTMathTable()
|
||||
// XCTAssertEqual(table.type, .table);
|
||||
//
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let list2 = MTMathList()
|
||||
// list2.add(atom3)
|
||||
// list2.add(atom2)
|
||||
//
|
||||
// table.set(cell: list, forRow:3, column:2)
|
||||
// table.set(cell: list2, forRow:1, column:0)
|
||||
//
|
||||
// table.set(alignment: .left, forColumn: 2)
|
||||
// table.set(alignment: .right, forColumn:1)
|
||||
//
|
||||
// // Verify that everything is created correctly
|
||||
// XCTAssertEqual(table.cells.count, 4); // 4 rows
|
||||
// XCTAssertNotNil(table.cells[0]);
|
||||
// XCTAssertEqual(table.cells[0].count, 0); // 0 elements in row 0
|
||||
// XCTAssertEqual(table.cells[1].count, 1); // 1 element in row 1
|
||||
// XCTAssertNotNil(table.cells[2]);
|
||||
// XCTAssertEqual(table.cells[2].count, 0);
|
||||
// XCTAssertEqual(table.cells[3].count, 3);
|
||||
//
|
||||
// // Verify the elements in the rows
|
||||
// XCTAssertEqual(table.cells[1][0].atoms.count, 2);
|
||||
// XCTAssertEqual(table.cells[1][0], list2);
|
||||
// XCTAssertNotNil(table.cells[3][0]);
|
||||
// XCTAssertEqual(table.cells[3][0].atoms.count, 0);
|
||||
//
|
||||
// XCTAssertNotNil(table.cells[3][0]);
|
||||
// XCTAssertEqual(table.cells[3][0].atoms.count, 0);
|
||||
//
|
||||
// XCTAssertNotNil(table.cells[3][1]);
|
||||
// XCTAssertEqual(table.cells[3][1].atoms.count, 0);
|
||||
//
|
||||
// XCTAssertEqual(table.cells[3][2], list);
|
||||
//
|
||||
// XCTAssertEqual(table.numRows, 4);
|
||||
// XCTAssertEqual(table.numColumns, 3);
|
||||
//
|
||||
// // Verify the alignments
|
||||
// XCTAssertEqual(table.alignments.count, 3);
|
||||
// XCTAssertEqual(table.alignments[0], .center);
|
||||
// XCTAssertEqual(table.alignments[1], .right);
|
||||
// XCTAssertEqual(table.alignments[2], .left);
|
||||
// }
|
||||
//
|
||||
// func testCopyMathTable() throws {
|
||||
// let table = MTMathTable()
|
||||
// XCTAssertEqual(table.type, .table);
|
||||
//
|
||||
// let list = MTMathList()
|
||||
// let atom = MTMathAtomFactory.placeholder()
|
||||
// let atom2 = MTMathAtomFactory.times()
|
||||
// let atom3 = MTMathAtomFactory.divide()
|
||||
// list.add(atom)
|
||||
// list.add(atom2);
|
||||
// list.add(atom3)
|
||||
//
|
||||
// let list2 = MTMathList()
|
||||
// list2.add(atom3)
|
||||
// list2.add(atom2)
|
||||
//
|
||||
// table.set(cell:list, forRow:0, column:1)
|
||||
// table.set(cell:list2, forRow:0, column:2)
|
||||
//
|
||||
// table.set(alignment: .left, forColumn:2)
|
||||
// table.set(alignment: .right, forColumn:1)
|
||||
// table.interRowAdditionalSpacing = 3;
|
||||
// table.interColumnSpacing = 10;
|
||||
//
|
||||
// let copy = table.copy() as! MTMathTable
|
||||
// try checkAtomCopy(copy, original:table, forTest:self)
|
||||
// XCTAssertEqual(copy.interColumnSpacing, table.interColumnSpacing);
|
||||
// XCTAssertEqual(copy.interRowAdditionalSpacing, table.interRowAdditionalSpacing);
|
||||
// XCTAssertEqual(copy.alignments, table.alignments);
|
||||
// XCTAssertNotEqual(copy.alignments, table.alignments);
|
||||
//
|
||||
// XCTAssertNotEqual(copy.cells, table.cells);
|
||||
// XCTAssertNotEqual(copy.cells[0], table.cells[0]);
|
||||
// XCTAssertEqual(copy.cells[0].count, table.cells[0].count);
|
||||
// XCTAssertEqual(copy.cells[0][0].atoms.count, 0);
|
||||
// XCTAssertNotEqual(copy.cells[0][0], table.cells[0][0]);
|
||||
// try checkListCopy(copy.cells[0][1], original:list, forTest:self)
|
||||
// try checkListCopy(copy.cells[0][2], original:list2, forTest:self)
|
||||
// }
|
||||
//
|
||||
func checkAtomCopy(_ copy:MTMathAtom?, original:MTMathAtom?, forTest test:String) throws {
|
||||
guard let copy = copy, let original = original else { return }
|
||||
XCTAssertEqual(copy.type, original.type, test)
|
||||
XCTAssertEqual(copy.nucleus, original.nucleus, test)
|
||||
// Should be different objects with the same content
|
||||
XCTAssertNotEqual(copy, original, test)
|
||||
}
|
||||
|
||||
func checkListCopy(_ copy:MTMathList?, original:MTMathList?, forTest test:String) throws {
|
||||
guard let copy = copy, let original = original else { return }
|
||||
XCTAssertEqual(copy.atoms.count, original.atoms.count, test)
|
||||
for (i, copyAtom) in copy.atoms.enumerated() {
|
||||
let origAtom = original.atoms[i];
|
||||
try self.checkAtomCopy(copyAtom, original:origAtom, forTest:test)
|
||||
}
|
||||
}
|
||||
|
||||
func testCopy() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let list2 = MTMathList(list)
|
||||
try checkListCopy(list2, original:list, forTest:self.description)
|
||||
}
|
||||
|
||||
func testAtomInit() throws {
|
||||
var atom = MTMathAtom(type: .open, value: "(")
|
||||
XCTAssertEqual(atom.nucleus, "(")
|
||||
XCTAssertEqual(atom.type, .open)
|
||||
|
||||
atom = MTMathAtom(type: .radical, value:"(")
|
||||
XCTAssertEqual(atom.nucleus, "");
|
||||
XCTAssertEqual(atom.type, .radical);
|
||||
}
|
||||
|
||||
func testAtomScripts() throws {
|
||||
var atom = MTMathAtom(type: .open, value:"(")
|
||||
XCTAssertTrue(atom.isScriptAllowed())
|
||||
atom.subScript = MTMathList()
|
||||
XCTAssertNotNil(atom.subScript);
|
||||
atom.superScript = MTMathList()
|
||||
XCTAssertNotNil(atom.superScript);
|
||||
|
||||
atom = MTMathAtom(type: .boundary, value:"(")
|
||||
XCTAssertFalse(atom.isScriptAllowed());
|
||||
// Can set to nil
|
||||
atom.subScript = nil;
|
||||
XCTAssertNil(atom.subScript);
|
||||
atom.superScript = nil;
|
||||
XCTAssertNil(atom.superScript);
|
||||
// Can't set to value
|
||||
let list = MTMathList()
|
||||
|
||||
XCTExpectFailure("No sub/super-script on boundary atoms", options: options) {
|
||||
XCTAssertThrowsError(atom.subScript = list)
|
||||
XCTAssertThrowsError(atom.superScript = list)
|
||||
}
|
||||
}
|
||||
|
||||
func testAtomCopy() throws {
|
||||
let list = MTMathList()
|
||||
let atom1 = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom1)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let list2 = MTMathList()
|
||||
list2.add(atom3)
|
||||
list2.add(atom2)
|
||||
|
||||
let atom = MTMathAtom(type: .open, value:"(")
|
||||
atom.subScript = list;
|
||||
atom.superScript = list2;
|
||||
let copy : MTMathAtom = atom.copy()
|
||||
|
||||
try checkAtomCopy(copy, original:atom, forTest:self.description)
|
||||
try checkListCopy(copy.superScript, original:atom.superScript, forTest:self.description)
|
||||
try checkListCopy(copy.subScript, original:atom.subScript, forTest:self.description)
|
||||
}
|
||||
|
||||
func testCopyFraction() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let list2 = MTMathList()
|
||||
list2.add(atom3)
|
||||
list2.add(atom2)
|
||||
|
||||
let frac = MTFraction(hasRule: false)
|
||||
XCTAssertEqual(frac.type, .fraction);
|
||||
frac.numerator = list;
|
||||
frac.denominator = list2;
|
||||
frac.leftDelimiter = "a";
|
||||
frac.rightDelimiter = "b";
|
||||
|
||||
let copy = MTFraction(frac)
|
||||
try checkAtomCopy(copy, original:frac, forTest:self.description)
|
||||
try checkListCopy(copy.numerator, original:frac.numerator, forTest:self.description)
|
||||
try checkListCopy(copy.denominator, original:frac.denominator, forTest:self.description)
|
||||
XCTAssertFalse(copy.hasRule)
|
||||
XCTAssertEqual(copy.leftDelimiter, "a");
|
||||
XCTAssertEqual(copy.rightDelimiter, "b");
|
||||
}
|
||||
|
||||
func testCopyRadical() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let list2 = MTMathList()
|
||||
list2.add(atom3)
|
||||
list2.add(atom2)
|
||||
|
||||
let rad = MTRadical()
|
||||
XCTAssertEqual(rad.type, .radical)
|
||||
rad.radicand = list;
|
||||
rad.degree = list2;
|
||||
|
||||
let copy = MTRadical(rad)
|
||||
try checkAtomCopy(copy, original:rad, forTest:self.description)
|
||||
try checkListCopy(copy.radicand, original:rad.radicand ,forTest:self.description)
|
||||
try checkListCopy(copy.degree, original:rad.degree, forTest:self.description)
|
||||
}
|
||||
|
||||
func testCopyLargeOperator() throws {
|
||||
let lg = MTLargeOperator(value: "lim", limits:true)
|
||||
XCTAssertEqual(lg.type, .largeOperator);
|
||||
XCTAssertTrue(lg.limits);
|
||||
|
||||
let copy = MTLargeOperator(lg)
|
||||
try checkAtomCopy(copy, original:lg, forTest:self.description)
|
||||
XCTAssertEqual(copy.limits, lg.limits);
|
||||
}
|
||||
|
||||
func testCopyInner() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let inner = MTInner()
|
||||
inner.innerList = list;
|
||||
inner.leftBoundary = MTMathAtom(type: .boundary, value: "(")
|
||||
inner.rightBoundary = MTMathAtom(type: .boundary, value:")")
|
||||
XCTAssertEqual(inner.type, .inner);
|
||||
|
||||
let copy = MTInner(inner)
|
||||
try checkAtomCopy(copy, original:inner, forTest:self.description)
|
||||
try checkListCopy(copy.innerList, original:inner.innerList, forTest:self.description)
|
||||
try checkAtomCopy(copy.leftBoundary!, original:inner.leftBoundary, forTest:self.description)
|
||||
try checkAtomCopy(copy.rightBoundary, original:inner.rightBoundary, forTest:self.description)
|
||||
}
|
||||
|
||||
func testSetInnerBoundary() throws {
|
||||
let inner = MTInner()
|
||||
|
||||
// Can set non-nil
|
||||
inner.leftBoundary = MTMathAtom(type: .boundary, value:"(")
|
||||
inner.rightBoundary = MTMathAtom(type: .boundary, value:")")
|
||||
XCTAssertNotNil(inner.leftBoundary);
|
||||
XCTAssertNotNil(inner.rightBoundary);
|
||||
// Can set nil
|
||||
inner.leftBoundary = nil;
|
||||
inner.rightBoundary = nil;
|
||||
XCTAssertNil(inner.leftBoundary);
|
||||
XCTAssertNil(inner.rightBoundary);
|
||||
// Can't set non boundary
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
XCTExpectFailure("Setting illegal boundary atoms", options: options) {
|
||||
XCTAssertThrowsError(inner.leftBoundary = atom);
|
||||
XCTAssertThrowsError(inner.rightBoundary = atom);
|
||||
}
|
||||
}
|
||||
|
||||
func testCopyOverline() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let over = MTOverLine()
|
||||
XCTAssertEqual(over.type, .overline);
|
||||
over.innerList = list;
|
||||
|
||||
let copy = MTOverLine(over)
|
||||
try checkAtomCopy(copy, original:over, forTest:self.description)
|
||||
try checkListCopy(copy.innerList, original:over.innerList, forTest:self.description)
|
||||
}
|
||||
|
||||
func testCopyUnderline() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let under = MTUnderLine()
|
||||
XCTAssertEqual(under.type, .underline);
|
||||
under.innerList = list;
|
||||
|
||||
let copy = MTUnderLine(under)
|
||||
try checkAtomCopy(copy, original:under, forTest:self.description)
|
||||
try checkListCopy(copy.innerList, original:under.innerList, forTest:self.description)
|
||||
}
|
||||
|
||||
func testCopyAcccent() throws {
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let accent = MTAccent(value: "^")
|
||||
XCTAssertEqual(accent.type, .accent);
|
||||
accent.innerList = list;
|
||||
|
||||
let copy = MTAccent(accent)
|
||||
try checkAtomCopy(copy, original:accent, forTest:self.description)
|
||||
try checkListCopy(copy.innerList ,original:accent.innerList, forTest:self.description)
|
||||
}
|
||||
|
||||
func testCopySpace() throws {
|
||||
let space = MTMathSpace(space: 3)
|
||||
XCTAssertEqual(space.type, .space);
|
||||
|
||||
let copy = MTMathSpace(space)
|
||||
try checkAtomCopy(copy, original:space, forTest:self.description)
|
||||
XCTAssertEqual(space.space, copy.space);
|
||||
}
|
||||
|
||||
func testCopyStyle() throws {
|
||||
let style = MTMathStyle(style: .script)
|
||||
XCTAssertEqual(style.type, .style);
|
||||
|
||||
let copy = MTMathStyle(style)
|
||||
try checkAtomCopy(copy, original:style, forTest:self.description)
|
||||
XCTAssertEqual(style.style, copy.style);
|
||||
}
|
||||
|
||||
func testCreateMathTable() throws {
|
||||
let table = MTMathTable()
|
||||
XCTAssertEqual(table.type, .table);
|
||||
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let list2 = MTMathList()
|
||||
list2.add(atom3)
|
||||
list2.add(atom2)
|
||||
|
||||
table.set(cell: list, forRow:3, column:2)
|
||||
table.set(cell: list2, forRow:1, column:0)
|
||||
|
||||
table.set(alignment: .left, forColumn: 2)
|
||||
table.set(alignment: .right, forColumn:1)
|
||||
|
||||
// Verify that everything is created correctly
|
||||
XCTAssertEqual(table.cells.count, 4); // 4 rows
|
||||
XCTAssertNotNil(table.cells[0]);
|
||||
XCTAssertEqual(table.cells[0].count, 0); // 0 elements in row 0
|
||||
XCTAssertEqual(table.cells[1].count, 1); // 1 element in row 1
|
||||
XCTAssertNotNil(table.cells[2]);
|
||||
XCTAssertEqual(table.cells[2].count, 0);
|
||||
XCTAssertEqual(table.cells[3].count, 3);
|
||||
|
||||
// Verify the elements in the rows
|
||||
XCTAssertEqual(table.cells[1][0].atoms.count, 2);
|
||||
XCTAssertEqual(table.cells[1][0], list2);
|
||||
XCTAssertNotNil(table.cells[3][0]);
|
||||
XCTAssertEqual(table.cells[3][0].atoms.count, 0);
|
||||
|
||||
XCTAssertNotNil(table.cells[3][0]);
|
||||
XCTAssertEqual(table.cells[3][0].atoms.count, 0);
|
||||
|
||||
XCTAssertNotNil(table.cells[3][1]);
|
||||
XCTAssertEqual(table.cells[3][1].atoms.count, 0);
|
||||
|
||||
XCTAssertEqual(table.cells[3][2], list);
|
||||
|
||||
XCTAssertEqual(table.numRows, 4);
|
||||
XCTAssertEqual(table.numColumns, 3);
|
||||
|
||||
// Verify the alignments
|
||||
XCTAssertEqual(table.alignments.count, 3);
|
||||
XCTAssertEqual(table.alignments[0], .center);
|
||||
XCTAssertEqual(table.alignments[1], .right);
|
||||
XCTAssertEqual(table.alignments[2], .left);
|
||||
}
|
||||
|
||||
func testCopyMathTable() throws {
|
||||
let table = MTMathTable()
|
||||
XCTAssertEqual(table.type, .table);
|
||||
|
||||
let list = MTMathList()
|
||||
let atom = MTMathAtomFactory.placeholder()
|
||||
let atom2 = MTMathAtomFactory.times()
|
||||
let atom3 = MTMathAtomFactory.divide()
|
||||
list.add(atom)
|
||||
list.add(atom2);
|
||||
list.add(atom3)
|
||||
|
||||
let list2 = MTMathList()
|
||||
list2.add(atom3)
|
||||
list2.add(atom2)
|
||||
|
||||
table.set(cell:list, forRow:0, column:1)
|
||||
table.set(cell:list2, forRow:0, column:2)
|
||||
|
||||
table.set(alignment: .left, forColumn:2)
|
||||
table.set(alignment: .right, forColumn:1)
|
||||
table.interRowAdditionalSpacing = 3;
|
||||
table.interColumnSpacing = 10;
|
||||
|
||||
let copy = MTMathTable(table)
|
||||
try checkAtomCopy(copy, original:table, forTest:self.description)
|
||||
XCTAssertEqual(copy.interColumnSpacing, table.interColumnSpacing);
|
||||
XCTAssertEqual(copy.interRowAdditionalSpacing, table.interRowAdditionalSpacing);
|
||||
XCTAssertEqual(copy.alignments, table.alignments)
|
||||
|
||||
XCTAssertNotEqual(copy.cells, table.cells);
|
||||
XCTAssertNotEqual(copy.cells[0], table.cells[0] );
|
||||
XCTAssertEqual(copy.cells[0].count, table.cells[0].count);
|
||||
XCTAssertEqual(copy.cells[0][0].atoms.count, 0);
|
||||
XCTAssertNotEqual(copy.cells[0][0], table.cells[0][0]);
|
||||
try checkListCopy(copy.cells[0][1], original:list, forTest:self.description)
|
||||
try checkListCopy(copy.cells[0][2], original:list2, forTest:self.description)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user