jf-roku/.vscode/brighterscript.code-snippets

{
    "rooibos beforeEach": {
        "prefix": "beforeEach",
        "body": [
            "@beforeEach",
            "function ${2:namespace}_${3:itGroup}_beforeEach()",
            "\t$0",
            "end function"
        ]
    },
    "rooibos afterEach": {
        "prefix": "afterEach",
        "body": [
            "@afterEach",
            "function ${2:namespace}_${3:itGroup}_afterEach()",
            "\t$0",
            "end function"
        ]
    },
    "rooibos setup": {
        "prefix": "setup",
        "body": [
            "@setup",
            "function ${2:namespace}_setup()",
            "\t$0",
            "end function"
        ]
    },
    "rooibos tearDown": {
        "prefix": "tearDown",
        "body": [
            "@tearDown",
            "function ${2:namespace}_tearDown()",
            "\t$0",
            "end function"
        ]
    },
    "rooibos ignore": {
        "prefix": "ignore",
        "body": [
            "@ignore ${1:reason}",
            "$0"
        ]
    },
    "rooibos only": {
        "prefix": "only",
        "body": [
            "@only",
            "$0"
        ]
    },
    "rooibos testSuite": {
        "prefix": "suite",
        "body": [
            "@suite(\"$1\")",
            "$0"
        ]
    },
    "rooibos testcase": {
        "prefix": "it",
        "body": [
            "@it(\"$1\")",
            "function _()",
            "\t$0",
            "end function"
        ]
    },
    "rooibos params": {
        "prefix": "params",
        "body": [
            "@params(${1:values})$0"
        ]
    },
    "rooibos it": {
        "prefix": "describe",
        "body": [
            "'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++",
            "@describe(\"${1:groupName}\")",
            "'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++",
            "",
            "$0"
        ]
    },
    "rooibos stub": {
        "prefix": "stub",
        "body": [
            "m.stub(${1:target}, \"${2:methodName}\", [${3:methodArgs}], ${4:result})",
            "$0"
        ]
    },
    "rooibos mock": {
        "prefix": "expect",
        "body": [
            "${1:mockName} = m.mock(${2:target}, \"${3:methodName}\", ${4:expectedNumberOfcalls}, [${5:methodArgs}], ${6:result})",
            "$0"
        ]
    },
    "rooibos expect": {
        "prefix": "expect",
        "body": [
            "m.expectOnce(${1:target}, \"${2:methodName}\", ${3:expectedNumberOfcalls}, [${4:methodArgs}], ${5:result})",
            "$0"
        ]
    },
    "rooibos expectOnce": {
        "prefix": "expectOnce",
        "body": [
            "m.expectOnce(${1:target}, \"${2:methodName}\", [${3:methodArgs}], ${4:result})",
            "$0"
        ]
    },
    "rooibos expectCallfunc": {
        "prefix": "expectCallfunc",
        "body": [
            "m.expectOnce(${1:target}, \"callFunc\", [\"${2:methodName}\", ${3:methodArgs}], ${4:result})",
            "$0"
        ]
    },
    "rooibos expectObserveNodeField": {
        "prefix": "eonf",
        "body": [
            "m.expectOnce(${1:target}, \"observeNodeField\", [${2:node},\"${3:fieldName}\", m.${4:callback}])",
            "$0"
        ]
    },
    "rooibos expectUnObserveNodeField": {
        "prefix": "eunf",
        "body": [
            "m.expectOnce(${1:target}, \"unobserveNodeField\", [${2:node},\"${:fieldName}\", m.${4:callback}])",
            "$0"
        ]
    },
    "rooibos expectObjectOnce": {
        "prefix": "expectObjectOnce",
        "body": [
            "${1:name} = { \"id\" : \"${1:name}\" }",
            "m.expectOnce(${2:target}, \"${3:methodName}\", [${4:methodArgs}], ${1:name})",
            "$0"
        ]
    },
    "rooibos expectGetInstance": {
        "prefix": "expectGetInstance",
        "body": [
            "${1:name} = { \"id\" : \"${1:name}\" }",
            "m.expectOnce(${2:target}, \"getInstance\", [\"${3:instanceName}\"], ${1:name})",
            "$0"
        ]
    },
    "rooibos expectCreateSGNode": {
        "prefix": "expectCreateSGNode",
        "body": [
            "${1:name} = { \"id\" : \"${1:name}\" }",
            "m.expectOnce(${2:target}, \"createSGNode\", [\"${3:nodeType}\"$0], ${1:name})"
        ]
    },
    "rooibos expectGetClassInstance": {
        "prefix": "expectGetClassInstance",
        "body": [
            "${1:name} = { \"id\" : \"${1:name}\" }",
            "m.expectOnce(${2:target}, \"getClassInstance\", [\"${3:instanceName}\"], ${1:name})",
            "$0"
        ]
    },
    "rooibos expectExpectOnce": {
        "prefix": "expectExpect",
        "body": [
            "${1:name} = { \"id\" : \"${1:name}\" }",
            "m.expectOnce(${2:target}, \"${3:methodName}\", [${4:methodArgs}], ${1:name})",
            "m.expectOnce(${1:name}, \"${5:methodName}\", [${6:methodArgs}], ${7:name})",
            "$0"
        ]
    },
    "rooibos expectNone": {
        "prefix": "expectNone",
        "body": [
            "m.expectNone(${1:target}, \"${2:methodName}\")",
            "$0"
        ]
    },
    "rooibos assertFalse": {
        "prefix": "assertFalse",
        "body": [
            "m.assertFalse(${1:value})",
            "$0"
        ]
    },
    "rooibos assertAsync": {
        "prefix": "assertAsync",
        "body": [
            "m.AssertAsyncField(${1:value}, $2{:fieldName})",
            "$0"
        ]
    },
    "rooibos assertTrue": {
        "prefix": "assertTrue",
        "body": [
            "m.assertTrue(${1:value})",
            "$0"
        ]
    },
    "rooibos assertEqual": {
        "prefix": "assertEqual",
        "body": [
            "m.assertEqual(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertLike": {
        "prefix": "assertLike",
        "body": [
            "m.assertLike(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNotEqual": {
        "prefix": "assertNotEqual",
        "body": [
            "m.assertNotEqual(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertInvalid": {
        "prefix": "assertInvalid",
        "body": [
            "m.assertInvalid(${1:value})",
            "$0"
        ]
    },
    "rooibos assertNotInvalid": {
        "prefix": "assertNotInvalid",
        "body": [
            "m.assertNotInvalid(${1:value})",
            "$0"
        ]
    },
    "rooibos assertAAHasKey": {
        "prefix": "assertAAHasKey",
        "body": [
            "m.assertAAHasKey(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertAANotHasKey": {
        "prefix": "assertAANotHasKey",
        "body": [
            "m.assertAANotHasKey(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertAAHasKeys": {
        "prefix": "assertAAHasKeys",
        "body": [
            "m.assertAAHasKeys(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertAANotHasKeys": {
        "prefix": "assertAANotHasKeys",
        "body": [
            "m.assertAANotHasKeys(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayContains": {
        "prefix": "assertArrayContains",
        "body": [
            "m.assertArrayContains(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayNotContains": {
        "prefix": "assertArrayNotContains",
        "body": [
            "m.assertArrayNotContains(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayContainsSubset": {
        "prefix": "assertArrayContainsSubset",
        "body": [
            "m.assertArrayContainsSubset(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayContainsAAs": {
        "prefix": "assertArrayContainsAAs",
        "body": [
            "m.assertArrayContainsAAs(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayNotContainsSubset": {
        "prefix": "assertArrayNotContainsSubset",
        "body": [
            "m.assertArrayNotContainsSubset(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayCount": {
        "prefix": "assertArrayCount",
        "body": [
            "m.assertArrayCount(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertArrayNotCount": {
        "prefix": "assertArrayNotCount",
        "body": [
            "m.assertArrayNotCount(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertEmpty": {
        "prefix": "assertEmpty",
        "body": [
            "m.assertEmpty(${1:value})",
            "$0"
        ]
    },
    "rooibos assertNotEmpty": {
        "prefix": "assertNotEmpty",
        "body": [
            "m.assertNotEmpty(${1:value})",
            "$0"
        ]
    },
    "rooibos assertArrayContainsOnlyValuesOfType": {
        "prefix": "assertArrayContainsOnlyValuesOfType",
        "body": [
            "m.assertArrayContainsOnlyValuesOfType(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertType": {
        "prefix": "assertType",
        "body": [
            "m.assertType(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertSubType": {
        "prefix": "assertSubType",
        "body": [
            "m.assertSubType(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNodeCount": {
        "prefix": "assertNodeCount",
        "body": [
            "m.assertNodeCount(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNodeNotCount": {
        "prefix": "assertNodeNotCount",
        "body": [
            "m.assertNodeNotCount(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNodeEmpty": {
        "prefix": "assertNodeEmpty",
        "body": [
            "m.assertNodeEmpty(${1:value})",
            "$0"
        ]
    },
    "rooibos assertNodeNotEmpty": {
        "prefix": "assertNodeNotEmpty",
        "body": [
            "m.assertNodeNotEmpty(${1:value})",
            "$0"
        ]
    },
    "rooibos assertNodeContains": {
        "prefix": "assertNodeContains",
        "body": [
            "m.assertNodeContains(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNodeNotContains": {
        "prefix": "assertNodeNotContains",
        "body": [
            "m.assertNodeNotContains(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNodeContainsFields": {
        "prefix": "assertNodeContainsFields",
        "body": [
            "m.assertNodeContainsFields(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertNodeNotContainsFields": {
        "prefix": "assertNodeNotContainsFields",
        "body": [
            "m.assertNodeNotContainsFields(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertAAContainsSubset": {
        "prefix": "assertAAContainsSubset",
        "body": [
            "m.assertAAContainsSubset(${1:value}, ${2:expected})",
            "$0"
        ]
    },
    "rooibos assertMocks": {
        "prefix": "assertMocks",
        "body": [
            "m.assertMocks(${1:value}, ${2:expected})",
            "$0"
        ]
    }
}