//

// InterpreterTests.swift

// ShapeScriptTests

//

// Created by Nick Lockwood on 08/11/2018.

// Copyright © 2018 Nick Lockwood. All rights reserved.

//

@testable import Euclid

@testable import ShapeScript

import XCTest

class InterpreterTests: XCTestCase {

// MARK: Random numbers

func testRandomSeedTruncation() {

let random = RandomSequence(seed: Double(Int.max))

XCTAssert(random.seed < Double(Int.max))

}

func testRandomNumberConsistency() {

let context = EvaluationContext(source: "", delegate: nil)

XCTAssertEqual(context.random.seed, 0)

context.random = RandomSequence(seed: .random(in: 0 ..< 10))

_ = context.random.next()

let a = context.random.seed

do {

// Push a new block context

let newContext = context.push(.group)

XCTAssertEqual(a, newContext.random.seed) // test seed is not reset

_ = newContext.random.next()

XCTAssertNotEqual(a, newContext.random.seed)

XCTAssertNotEqual(a, context.random.seed) // test original seed also affected

context.random = RandomSequence(seed: a) // reset seed

}

do {

// Push a new block context

let newContext = context.push(.group)

newContext.random = RandomSequence(seed: .random(in: 11 ..< 20))

_ = newContext.random.next()

XCTAssertNotEqual(5, newContext.random.seed)

XCTAssertEqual(a, context.random.seed) // test original seed not affected

}

do {

// Push a new block context

let newContext = context.pushDefinition()

XCTAssertEqual(a, newContext.random.seed) // test seed is not reset

_ = newContext.random.next()

XCTAssertNotEqual(a, newContext.random.seed)

XCTAssertNotEqual(a, context.random.seed) // test original seed also affected

context.random = RandomSequence(seed: a) // reset seed

}

do {

// Push definition

let newContext = context.pushDefinition()

newContext.random = RandomSequence(seed: 0)

_ = newContext.random.next()

XCTAssertNotEqual(5, newContext.random.seed)

XCTAssertEqual(a, context.random.seed) // test original seed not affected

}

do {

// Push loop context

context.pushScope { context in

_ = context.random.next()

}

XCTAssertNotEqual(a, context.random.seed) // test original seed is affected

context.random = RandomSequence(seed: a) // reset seed

}

do {

// Push loop context

context.pushScope { context in

context.random = RandomSequence(seed: 99)

}

XCTAssertNotEqual(a, context.random.seed) // test original seed is affected

XCTAssertEqual(context.random.seed, 99) // random state is preserved

context.random = RandomSequence(seed: a) // reset seed

}

}

// MARK: Name

func testSetPrimitiveName() throws {

let program = try parse("""

cube { name "Foo" }

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

XCTAssertEqual(first.name, "Foo")

}

func testSetBuilderName() throws {

let program = try parse("""

extrude {

name "Foo"

circle

}

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

XCTAssertEqual(first.name, "Foo")

}

func testSetGroupName() throws {

let program = try parse("""

group {

name "Foo"

cube

sphere

}

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

XCTAssertEqual(first.name, "Foo")

XCTAssertNil(first.children.first?.name)

}

func testSetCustomBlockName() throws {

let program = try parse("""

define wheel {

scale 1 0.2 1

cylinder

}

wheel { name "Foo" }

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

XCTAssertEqual(first.name, "Foo")

XCTAssert(first.children.isEmpty)

}

func testSetCustomGroupBlockName() throws {

let program = try parse("""

define wheels {

scale 1 0.2 1

cylinder

translate 0 1 0

cylinder

}

wheels { name "Foo" }

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

XCTAssertEqual(first.name, "Foo")

XCTAssertNil(first.children.first?.name)

XCTAssertEqual(first.children.count, 2)

}

func testSetPathBlockName() throws {

let program = try parse("""

define wheel { circle }

wheel { name "Foo" }

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

XCTAssertEqual(first.name, "Foo")

guard case .path = first.type else {

XCTFail()

return

}

}

func testExtrudeNamedPath() throws {

let program = try parse("""

define wheel { circle }

extrude wheel { name "Foo" }

""")

let scene = try evaluate(program, delegate: nil)

let first = try XCTUnwrap(scene.children.first)

guard case .extrude = first.type else {

XCTFail()

return

}

}

func testSetNumberBlockName() throws {

let program = """

define foo {

42

}

print foo { name "Foo" }

"""

let range = program.range(of: "foo", range: program.range(of: "print foo")!)!

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error, RuntimeError(.assertionFailure(

"Blocks that return a number value cannot be assigned a name"

), at: range))

}

}

func testSetTupleBlockName() throws {

let program = """

define foo {

"bar"

42

}

print foo { name "Foo" }

"""

let range = program.range(of: "foo", range: program.range(of: "print foo")!)!

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error, RuntimeError(.assertionFailure(

"Blocks that return a string value cannot be assigned a name"

), at: range))

}

}

func testNameInvalidAtRoot() {

let program = """

name "Foo"

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("name", _)? = error?.type else {

XCTFail()

return

}

}

}

func testNameInvalidInDefine() {

let program = """

define foo {

name "Foo"

cube

}

foo

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("name", _)? = error?.type else {

XCTFail()

return

}

}

}

func testNameInvalidInCircle() {

let input = """

circle { name "Foo" }

"""

let delegate = TestDelegate()

XCTAssertThrowsError(try evaluate(parse(input), delegate: delegate)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error?.message, "Unexpected symbol 'name'")

}

}

func testNameInvalidInPath() {

let input = """

path { name "Foo" }

"""

let delegate = TestDelegate()

XCTAssertThrowsError(try evaluate(parse(input), delegate: delegate)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error?.message, "Unexpected symbol 'name'")

}

}

func testNameInvalidInText() {

let input = """

text { name "Foo" }

"""

let delegate = TestDelegate()

XCTAssertThrowsError(try evaluate(parse(input), delegate: delegate)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error?.message, "Unexpected symbol 'name'")

}

}

// MARK: Built-in symbol scope

func testOverrideColorInRootScope() {

let program = """

print black

define black white

print black

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.black, Color.white])

}

func testReferenceOverriddenColorInBlockScope() {

let program = """

print black

define black white

define foo {

print black

}

foo

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.black, Color.white])

}

func testOverrideColorInBlockScope() {

let program = """

define black white

define foo {

define black red

print black

}

foo

print black

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.red, Color.white])

}

func testOverrideGlobalFunction() {

let program = """

define cos(foo) { print "hello" }

cube { cos(5) }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, ["hello"])

}

func testNoOverridePathFunction() {

let program = """

define point(foo) { print "hello" }

path { point 1 0 }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [])

}

// MARK: Option scope

func testOptionValidInBlockDefine() {

let program = """

define foo {

option bar 5

}

foo { bar 5 }

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

func testOptionReferencedInDefine() {

let program = """

define foo {

option bar 5

define baz bar/2

}

foo { bar 6 }

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

func testOptionInvalidInFunctionDefine() {

let program = """

define foo() {

option bar 5

}

foo()

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error?.message, "Unexpected symbol 'option'")

XCTAssertEqual(error?.hint, "The 'option' command is not available in"

+ " this context. Did you mean 'define'?")

guard case .unknownSymbol("option", _)? = error?.type else {

XCTFail()

return

}

}

}

func testOptionInvalidInConditionalScope() {

let program = """

define foo {

if true {

option bar 5

}

}

foo {}

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("option", _)? = error?.type else {

XCTFail()

return

}

}

}

func testOptionInvalidInPrimitive() {

let program = """

cube {

option foo 5

}

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("option", _)? = error?.type else {

XCTFail()

return

}

}

}

func testOptionInvalidAtRoot() {

let program = "option foo 5"

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("option", _)? = error?.type else {

XCTFail()

return

}

}

}

func testOptionDoesntShadowDefineInCallerScope() {

let program = """

define foo {

option x 0

print x

}

define bar {

define x 5

foo { x x }

}

bar

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5])

}

func testDefineInCallerScopeDoesntShadowOptionInBlock() {

let program = """

define foo {

option bar 1

print bar

}

foo

define bar 2

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [1])

}

func testOptionShadowsGlobalFunction() throws {

let program = try parse("""

define blob {

option length 2

cube { size length }

}

blob

""")

let context = EvaluationContext(source: program.source, delegate: nil)

XCTAssertNoThrow(try program.evaluate(in: context))

let geometry = try XCTUnwrap(context.children.first?.value as? Geometry)

XCTAssertEqual(geometry.transform.scale, .init(size: 2))

}

func testOptionShadowsGlobalFunction2() throws {

let program = try parse("""

define blob {

option length 2

cube { size length }

}

blob { length 3 }

""")

let context = EvaluationContext(source: program.source, delegate: nil)

XCTAssertNoThrow(try program.evaluate(in: context))

let geometry = try XCTUnwrap(context.children.first?.value as? Geometry)

XCTAssertEqual(geometry.transform.scale, .init(size: 3))

}

// MARK: Block scope

func testLocalSymbolsNotPassedToCommand() {

let program = """

define foo {

print baz

}

define bar {

define baz 5

foo

}

bar

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error?.range, program.range(of: "baz"))

guard case .unknownSymbol("baz", _)? = error?.type else {

XCTFail()

return

}

}

}

func testOptionsPassedToCommand() {

let program = """

define foo {

option baz 0

print baz

}

define bar {

foo { baz 5 }

}

bar

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5])

}

func testDefineNotPassedToCustomCommand() {

let program = """

define foo {

option baz 2

print baz

}

foo { define baz 5 }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [2])

}

func testDefineNotPassedToBuiltInCommand() {

let program = """

define foo polygon {

define sides 7

}

// should match default of 5 sides

print foo.points.count - 1

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5])

}

func testDuplicateOptionsPassedToCommand() {

let program = """

define foo {

option baz 0

print baz

}

define bar {

foo {

baz 5

baz 6

}

}

bar

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [6])

}

func testConditionalOptionPassedToCommand() {

let program = """

define foo polygon {

if true {

sides 7

}

}

print foo.points.count - 1

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [7])

}

func testConditionalOptionPassedToCustomCommand() {

let program = """

define foo {

option baz 1

print baz

}

foo {

if true {

baz 5

}

}

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5])

}

func testOptionDefaultValueFromGlobalConstant() {

let program = """

define baz 5

define foo {

option bar baz

print bar

}

foo

foo { bar 6 }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5, 6])

}

func testOptionDefaultValueFromLocalConstant() {

let program = """

define foo {

define baz 5

option bar baz

print bar

}

foo

foo { bar 6 }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5, 6])

}

func testOptionTypeEvaluationDoesNotChangeSeed() {

let program = """

seed 1

define foo {

option bar rnd

print bar

}

foo

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [0.23645552527159452])

}

func testOptionDefaultValueIsIdempotent() {

let program = """

define bar() {

print "bar"

5

}

define foo {

define baz bar()

option quux baz

print quux

}

foo { quux 6 }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, ["bar", 6]) // bar only called once, not twice

}

func testOptionCanReferenceOtherOption() {

let program = """

define foo {

option bar 5

option baz bar

print baz

}

foo { bar 6 }

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [6])

}

func testGlobalSymbolsAvailableToCommand() {

let program = """

define baz 5

define foo {

print baz

}

define bar {

foo

}

bar

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [5])

}

func testOptionsNotSuggestedForTypoInShapeBlock() {

let program = """

cube {

poption bar 0

}

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("poption", _)? = error?.type else {

XCTFail()

return

}

XCTAssertNotEqual(error?.suggestion, "option")

}

}

func testOptionsSuggestedForTypoInCustomBlock() {

let program = """

define foo {

poption bar 0

}

foo

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("poption", _)? = error?.type else {

XCTFail()

return

}

XCTAssertEqual(error?.suggestion, "option")

}

}

func testOptionNameSuggestedForTypoInBlock() {

let program = """

extrude { alon square }

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("alon", _)? = error?.type else {

XCTFail()

return

}

XCTAssertEqual(error?.suggestion, "along")

}

}

func testOptionNameSuggestedForTypoInCustomBlock() {

let program = """

define foo {

option bar 0

}

foo { baa 1 }

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("baa", _)? = error?.type else {

XCTFail()

return

}

XCTAssertEqual(error?.suggestion, "bar")

}

}

func testAlternativeNotSuggestedWhenValidSymbolUsedInInvalidContext() {

let program = """

define foo sphere

foo { detail 1 }

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("detail", _)? = error?.type else {

XCTFail()

return

}

XCTAssertNil(error?.suggestion)

}

}

func testShadowedColorInheritedByBlock() throws {

let program = """

define black 1 0 0

union {

color black

cube

}

"""

let scene = try evaluate(parse(program), delegate: nil)

XCTAssertEqual(scene.children.first?.material.color, Color(1, 0, 0))

}

// MARK: Position

func testCumulativePosition() throws {

let program = """

translate 1 0 0

cube { position 1 0 0 }

"""

let scene = try evaluate(parse(program), delegate: nil)

XCTAssertEqual(scene.children.first?.transform.offset.x, 2)

}

func testPositionValidInPrimitive() {

let program = """

cube { position 1 0 0 }

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

func testPositionValidInGroup() {

let program = """

group { position 1 0 0 }

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

func testPositionValidInBuilder() {

let program = """

extrude {

position 1 0 0

circle

}

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

func testPositionValidInCSG() {

let program = """

difference {

position 1 0 0

cube

sphere

}

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

func testPositionInvalidAtRoot() {

let program = """

position 1 0 0

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("position", _)? = error?.type else {

XCTFail()

return

}

}

}

func testPositionInvalidInDefine() {

let program = """

define foo {

position 1 0 0

cube

}

foo

"""

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

guard case .unknownSymbol("position", _)? = error?.type else {

XCTFail()

return

}

}

}

func testSetPositionWithTupleConstant() throws {

let program = """

define foo (1 0 0) 0

cube {

position foo

}

"""

let range = program.range(of: "foo", range: program.range(of: "position foo")!)!

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error, RuntimeError(.typeMismatch(

for: "position",

expected: "vector",

got: "tuple"

), at: range))

}

}

func testSetPositionWithTupleOfConstantAndLiteral() throws {

let program = """

define pos 1 0 0

cube {

position pos 7

}

"""

let range = program.range(of: "7")!

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error, RuntimeError(

.unexpectedArgument(for: "position", max: 1), at: range

))

}

}

func testDuplicatePositionCommand() throws {

let program = """

cube {

position 1

position 2

}

"""

XCTAssertNoThrow(try evaluate(parse(program), delegate: nil))

}

// MARK: Color

func testSetColorWithParens() throws {

let program = """

color (1 0 0)

print color

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.red])

}

func testColorWithoutParens() throws {

let program = """

color 1 0 0

print color

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.red])

}

func testSetColorWithSingleNumber() throws {

let program = """

color 0

print color

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.black])

}

func testSetColorWithConstant() throws {

let program = """

define red 1 0 0

color red

print color

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color.red])

}

func testSetColorWithTooManyElements() throws {

let program = """

color 1 0 0 0.5 0.9

print color

"""

let range = program.range(of: "0.9")!

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error, RuntimeError(

.unexpectedArgument(for: "color", max: 4), at: range

))

}

}

func testSetColorWithConstantWithTooManyElements() throws {

let program = """

define foo 1 0 0 0.5 0.9

color foo

print color

"""

let range = program.range(of: "foo", range: program.range(of: "color foo")!)!

XCTAssertThrowsError(try evaluate(parse(program), delegate: nil)) { error in

let error = try? XCTUnwrap(error as? RuntimeError)

XCTAssertEqual(error, RuntimeError(.typeMismatch(

for: "color", expected: "color", got: "tuple"

), at: range))

}

}

func testSetColorWithColorAlphaTuple() throws {

let program = """

color (1 0 0) 0.5

print color

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color(1, 0, 0, 0.5)])

}

func testSetColorWithColorAlphaTuple2() throws {

let program = """

color (1 0 0 1) 0.5

print color

"""

let delegate = TestDelegate()

XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))

XCTAssertEqual(delegate.log, [Color(1, 0, 0, 0.5)])

}

func testSetColorWithTupleConstant() throws {

let program = """

define foo (1 0 0) 0.5