# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionConcat

    let [
        l2.0 = getField(s1, "pattern") 
    ] 
    in 
        if (typeMatch(l2.0, 1088) ?: true) 
        then null 
        elif isString(l2.0) 
        then concat("This is", " a ", move(l2.0)) 
        else fail(7158201, "$concat supports only strings") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionReplaceOne

    let [
        l4.0 = getField(s1, "str") 
        l4.1 = (typeMatch(l4.0, 1088) ?: true) 
    ] 
    in 
        if !((l4.1 || isString(l4.0))) 
        then fail(7158302, "$replaceOne requires that 'input' be a string") 
        elif move(l4.1) 
        then null 
        else replaceOne(move(l4.0), "test", "nice place") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionSplit

    let [
        l6.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l6.0, 1088) ?: true) 
        then null 
        elif !(isString(l6.0)) 
        then fail(7158202, "$split string expression must be a string") 
        elif (l6.0 == "") 
        then [""] 
        else split(move(l6.0), " ") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionStrcasecmp
(toUpper(coerceToString("this IS a TEST.")) <=> 
    let [
        l9.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l9.0, 1088) ?: true) 
        then "" 
        elif typeMatch(l9.0, 999942) 
        then toUpper(coerceToString(move(l9.0))) 
        else fail(7158200, "$toUpper input type is not supported") 
) 
# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionSubstrBytes

    let [
        l11.0 = getField(s1, "str") 
    ] 
    in substrBytes(
        if (typeMatch(l11.0, 1088) ?: true) 
        then "" 
        elif (coerceToString(l11.0) ?: true) 
        then fail(5155608, "$substrBytes: string expression could not be resolved to a string") 
        else coerceToString(move(l11.0)) 
   , 10ll, 4ll) 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionSubstrCP

    let [
        l13.0 = getField(s1, "str") 
    ] 
    in substrCP(
        if (typeMatch(l13.0, 1088) ?: true) 
        then "" 
        elif (coerceToString(l13.0) ?: true) 
        then fail(5155708, "$substrCP: string expression could not be resolved to a string") 
        else coerceToString(move(l13.0)) 
   , 10, 4) 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionStrLenBytes

    let [
        l15.0 = getField(s1, "str") 
    ] 
    in 
        if (isString(l15.0) ?: false) 
        then strLenBytes(move(l15.0)) 
        else fail(5155800, "$strLenBytes requires a string argument") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionStrLenCP

    let [
        l17.0 = getField(s1, "str") 
    ] 
    in 
        if (isString(l17.0) ?: false) 
        then strLenCP(move(l17.0)) 
        else fail(5155900, "$strLenCP requires a string argument") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionToLower

    let [
        l19.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l19.0, 1088) ?: true) 
        then "" 
        elif typeMatch(l19.0, 999942) 
        then toLower(coerceToString(move(l19.0))) 
        else fail(7158200, "$toLower input type is not supported") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionToUpper

    let [
        l21.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l21.0, 1088) ?: true) 
        then "" 
        elif typeMatch(l21.0, 999942) 
        then toUpper(coerceToString(move(l21.0))) 
        else fail(7158200, "$toUpper input type is not supported") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionTrim

    let [
        l23.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l23.0, 1088) ?: true) 
        then null 
        elif isString(l23.0) 
        then trim(move(l23.0), ".") 
        else fail(5156302, "$trim input expression must be a string") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionIndexOfBytes

    let [
        l25.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l25.0, 1088) ?: true) 
        then null 
        elif isString(l25.0) 
        then indexOfBytes(move(l25.0), "is", 
            if (!(isNaN(0ll)) && false) 
            then fail(7158004, "$indexOfBytes start index must be positive") 
            else 0ll 
       ) 
        else fail(7158007, "$indexOfBytes string must resolve to a string or null") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionIndexOfCP

    let [
        l27.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l27.0, 1088) ?: true) 
        then null 
        elif isString(l27.0) 
        then indexOfCP(move(l27.0), "is", 
            if (!(isNaN(4)) && false) 
            then fail(7158004, "$indexOfCP start index must be positive") 
            else 4ll 
       ) 
        else fail(7158007, "$indexOfCP string must resolve to a string or null") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionIndexOfCP

    let [
        l29.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l29.0, 1088) ?: true) 
        then null 
        elif isString(l29.0) 
        then indexOfCP(move(l29.0), " ", 
            if (!(isNaN(1)) && false) 
            then fail(7158004, "$indexOfCP start index must be positive") 
            else 1ll 
       , 
            if (!(isNaN(3)) && false) 
            then fail(7158006, "$indexOfCP end index must be positive") 
            else 3ll 
       ) 
        else fail(7158007, "$indexOfCP string must resolve to a string or null") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionRegexFind

    let [
        l32.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l32.0, 1088) ?: true) 
        then null 
        elif isString(l32.0) 
        then 
            let [
                l33.0 = regexFind(PcreRegex(/test/), move(l32.0)) 
            ] 
            in 
                if exists(l33.0) 
                then makeOwn(move(l33.0)) 
                else fail(5073403, "$regexFind: error occurred while executing the regular expression") 
        
        else fail(5073401, "$regexFind: input must be of type string") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionRegexFindAll

    let [
        l36.0 = getField(s1, "str") 
        l36.1 = getField(s1, "pattern") 
    ] 
    in 
        if (typeMatch(l36.0, 1088) ?: true) 
        then [] 
        elif isString(l36.0) 
        then 
            if isNull(l36.1) 
            then [] 
            else 
                let [
                    l37.0 = regexFindAll(regexCompile(
                        if isString(l36.1) 
                        then 
                            if hasNullBytes(l36.1) 
                            then fail(5126602, "$regexFindAll: regex pattern must not have embedded null bytes") 
                            else l36.1 
                        
                        else 
                            if typeMatch(l36.1, 2048) 
                            then getRegexPattern(l36.1) 
                            else fail(5126601, "$regexFindAll: regex pattern must have either string or BSON RegEx type") 
                   , 
                        if typeMatch(l36.1, 2048) 
                        then getRegexFlags(l36.1) 
                        else "" 
                   ), move(l36.0)) 
                ] 
                in 
                    if exists(l37.0) 
                    then makeOwn(move(l37.0)) 
                    else fail(5073403, "$regexFindAll: error occurred while executing the regular expression") 
        
        else fail(5073401, "$regexFindAll: input must be of type string") 

# Golden test output of GoldenGenExpressionTest/TestExprStr
ExpressionRegexMatch

    let [
        l40.0 = getField(s1, "str") 
    ] 
    in 
        if (typeMatch(l40.0, 1088) ?: true) 
        then false 
        elif isString(l40.0) 
        then 
            let [
                l41.0 = regexMatch(PcreRegex(/test/), move(l40.0)) 
            ] 
            in 
                if exists(l41.0) 
                then makeOwn(move(l41.0)) 
                else fail(5073403, "$regexMatch: error occurred while executing the regular expression") 
        
        else fail(5073401, "$regexMatch: input must be of type string") 

