# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.

Describe 'Positive Parse Properties Tests' -Tags "CI" {
    It 'PositiveParsePropertiesTest' {
        # Just a bunch of random basic things here
        # This test doesn't need to check anything, if there are
        # any parse errors, the entire suite will fail because the
        # script will fail to parse.

        # No members
        class C1 {}

        # Simple field
        class C2 { $x; }

        # Simple typed field
        class C3 { [int] $x; }

        # Multiple fields, one line, last w/o semicolon
        class C4 { $x; $y }

        # Multiple fields, multiple lines
        class C5
        {
            $x
            $y
        }

        # Static field
        class C6 { static $x; }

        # Static field w/ type - order doesn't matter
        class C7a { static [hashtable] $x; }
        class C7b { [hashtable] static $x; }

        # Field using type defined in this scope
        class C8a { [C1] $c1; }
        class C8b { [c1] $c1; }

        # Field referring to self type
        class C9 { [C9] $c9; }

        # Hidden fields
        class C10a { hidden $x }
        class C10b { hidden [int] $x }
        class C10c { hidden static $x; static hidden $y }
        class C10d { hidden static [int] $x; static hidden [int] $y }
    }

    It 'Positive Parse Methods Tests' {
        # Just a bunch of random basic things here
        # This test doesn't need to check anything, if there are
        # any parse errors, the entire suite will fail because the
        # script will fail to parse.

        # No members
        class C1 {}

        # Simple method
        class C2 { f() {} }

        # Simple method with return type
        class C3 { [int] f() { return 1 } }

        # Multiple methods, one line
        class C4 { f() {} f1() {} }

        # Multiple methods w/ overloads
        class C5
        {
            f1() {}
            f1($a) {}
        }

        # Static method
        class C6 { static f() {} }

        # Static method w/ return type
        class C7 { static [hashtable] f1() { return @{} } }

        # Method using return type defined in this scope
        class C8a { [C1] f1() { return [C1]::new() } }
        class C8b { [c1] f1() { return [c1]::new() } }

        # Hidden methods
        class C10a { hidden F() { } }
        class C10b { hidden [void] F() { } }
        class C10c { hidden static F() { } static hidden G() { } }
        class C10d { hidden static [void] F() { } static hidden [void] G() { } }

         # return analysis
        class C11a { [int]foo() { try {throw "foo"} catch {throw $_} } }
        class C11b { [int]foo() { try {throw "foo"} finally {}; try {} catch {} } }
        class C11c { [int]foo() { try {throw "foo"} catch [ArgumentException] {throw $_} catch {throw $_} } }
        class C11d { [int]foo() { try {if (1 -eq 2) { throw "1"} else {throw "2"}} finally {} } }
        class C11e { [int]foo() { try {throw "foo"} catch [ArgumentException] {throw $_} catch {return 1} } }
        class C11f { [int]foo() { try {} finally {throw "bar"} } }
        class C11g { [int]foo() { do { return 1 } while ($false) } }
        class C11h { [int]foo() { try {throw "foo"} finally {} } }

        # local variables
        class C12a { static f() { [bigint]$foo = 42 } }
        class C12b { [void] f() { [bigint]$foo = 42 } }
        class C12c { [void] f() { [System.Management.Automation.Host.Rectangle]$foo = [System.Management.Automation.Host.Rectangle]::new(0, 0, 0, 0) } }
    }

    Context "Positive ParseMethods return type Test" {
        # Method with return type of self
        class C9 { [C9] f() { return [C9]::new() } }
        $c9 = [C9]::new().f()
        It "Expected a C9 returned" { $c9.GetType().Name | Should -Be C9 }
        class C9a { [C9a[]] f() { return [C9a]::new() } }
        $c9a = [C9a]::new().f()
        It "Expected a C9a[] returned" { $c9a.GetType().Name | Should -Be C9a[] }
        class C9b { [System.Collections.Generic.List[C9b]] f() { return [C9b]::new() } }
        $c9b = [C9b]::new().f()
        It "Expected a System.Collections.Generic.List[C9b] returned" {  $c9b -is [System.Collections.Generic.List[C9b]] | Should -BeTrue }
        It 'Methods returning object should return $null if no output was produced' {
            class Foo {
                [object] Bar1() { return & {} }
                static [object] Bar2() { return & {} }
            }
            # Test instance method
            [Foo]::new().Bar1() | Should -BeNullOrEmpty
            # Test static method
            [foo]::Bar2() | Should -BeNullOrEmpty
        }
    }

    It 'Positive ParseProperty Attributes Test' {
        class C1a { [ValidateNotNull()][int]$x; }
        class C1b
        {
            [ValidateNotNull()]
            [int]
            $x
        }
        class C1c
        {
            [ValidateNotNull()]
            [int]$x
        }
        class C1d
        {
            [ValidateNotNull()][int]
            $x
        }
    }

    It 'PositiveParseMethodAttributesTest' {
        class C1a { [Obsolete()][int] f() { return 0 } }
        class C1b
        {
            [Obsolete()]
            [int]
            f() { return 1 }
        }
        class C1c
        {
            [Obsolete("Message")]
            [int] f() { return 0 }
        }
        class C1d
        {
            [Obsolete()][int]
            f(){ return -1 }
        }
    }

    It 'Class Method Reference ConstantVars' {
        class C1
        {
            [bool] f1() { return $true }
            [bool] f2() { return $false }
            [object] f3() { return $null }
        }
    }

    It 'Positive Parsing Of DscResource' {
        [DscResource()]
        class C1
        {
            [DscProperty(Key)][string]$Key
            [bool] Test() { return $false }
            [C1] Get() { return $this }
            Set() {}
        }

        [DscResource()]
        class C2
        {
            [DscProperty(Key)][int]$Key = 1
            [bool] Test() { return $false }
            [C2] Get() { return $this }
            Set() {}
        }

        [DscResource()]
        class C4
        {
            [DscProperty(Key)][byte]$Key=1
            C4() { }
            C4($a) { }
            [bool] Test() { return $false }
            [C4] Get() { return $this }
            Set() {}
        }

        [DscResource()]
        class C5
        {
            [DscProperty(Key)][int]$Key = 1
            C5() { }
            static C5() { }
            C5($a) { }
            [bool] Test() { return $false }
            [C5] Get() { return $this }
            Set() {}
        }
    }

    It 'allows some useful implicit variables inside methods' {
        class C {
            [void] m()
            {
                $LASTEXITCODE
                $lastexitcode
                '111' -Match '1'
                $Matches
                $mAtches
                $error[0]
                $error
                $pwd
                foreach ($i in 1..10) {$foreach}
                switch ($i)
                {
                    '1' {
                        $switch
                    }
                }
            }
        }
    }

    It 'allowes [ordered] attribute inside methods' {
        class A
        {
            $h
            A()
            {
                $this.h = [ordered] @{}
            }
        }
        [A]::new().h.GetType().Name | Should -BeExactly 'OrderedDictionary'
    }
}

Describe 'Negative Parsing Tests' -Tags "CI" {
    ShouldBeParseError 'class' MissingNameAfterKeyword 5
    ShouldBeParseError 'class foo' MissingTypeBody 9
    ShouldBeParseError 'class foo {' MissingEndCurlyBrace 11
    ShouldBeParseError 'class foo { [int] }' IncompleteMemberDefinition 17
    ShouldBeParseError 'class foo { $private: }' InvalidVariableReference 12
    ShouldBeParseError 'class foo { [int]$global: }' InvalidVariableReference 17
    ShouldBeParseError 'class foo { [Attr()] }' IncompleteMemberDefinition 20
    ShouldBeParseError 'class foo {} class foo {}' MemberAlreadyDefined 13
    ShouldBeParseError 'class foo { $x; $x; }' MemberAlreadyDefined 16 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class foo { [int][string]$x; }' TooManyTypes 17
    ShouldBeParseError 'class foo { static static $x; }' DuplicateQualifier 19
    ShouldBeParseError 'class foo { [zz]$x; }' TypeNotFound 13
    ShouldBeParseError 'class foo { [zz]f() { return 0 } }' TypeNotFound 13
    ShouldBeParseError 'class foo { f([zz]$x) {} }' TypeNotFound 15

    ShouldBeParseError 'class C {} class C {}' MemberAlreadyDefined 11
    ShouldBeParseError 'class C { f(){} f(){} }' MemberAlreadyDefined 16 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class C { F(){} F($o){} [int] F($o) {return 1} }' MemberAlreadyDefined 24 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class C { f(){} f($a){} f(){} }' MemberAlreadyDefined 24 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class C { f([int]$a){} f([int]$b){} }' MemberAlreadyDefined 23 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class C { $x; [int]$x; }' MemberAlreadyDefined 14 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class C { static C($x) {} }' StaticConstructorCantHaveParameters 19 -SkipAndCheckRuntimeError
    ShouldBeParseError 'class C { static C([int]$x = 100) {} }' StaticConstructorCantHaveParameters 19 -SkipAndCheckRuntimeError

    ShouldBeParseError 'class C {f(){ return 1} }' VoidMethodHasReturn 14
    ShouldBeParseError 'class C {[int] f(){ return } }' NonVoidMethodMissingReturnValue 20
    ShouldBeParseError 'class C {[int] f(){} }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C {f(){ $x=1; if($x -lt 2){ return } elseif($x -gt 0 ) {return 1} else{return 2} return 3 } }' @("VoidMethodHasReturn", "VoidMethodHasReturn", "VoidMethodHasReturn") @(62,77,87)

    ShouldBeParseError 'class foo { [int] bar() { $y = $z; return $y} }' VariableNotLocal 31
    ShouldBeParseError 'class foo { bar() { foreach ($zz in $yy) { } } }' VariableNotLocal 36
    ShouldBeParseError 'class foo { bar() { foreach ($zz in $global:yy) { $abc = $zzzzz } } }' VariableNotLocal 57
    ShouldBeParseError 'class foo { bar() { try { $zz = 42 } finally { } $zz } }' VariableNotLocal 49
    ShouldBeParseError 'class foo { bar() { try { $zz = 42 } catch { } $zz } }' VariableNotLocal 47
    ShouldBeParseError 'class foo { bar() { switch (@()) { default { $aa = 42 } } $aa } }' VariableNotLocal 58
    ShouldBeParseError 'class C { $x; static bar() { $this.x = 1 } }' NonStaticMemberAccessInStaticMember 29
    ShouldBeParseError 'class C { $x; static $y = $this.x }' NonStaticMemberAccessInStaticMember 26

    ShouldBeParseError 'class C { [void]foo() { try { throw "foo"} finally { return } } }' ControlLeavingFinally 53
    ShouldBeParseError 'class C { [int]foo() { return; return 1 } }' NonVoidMethodMissingReturnValue 23
    ShouldBeParseError 'class C { [int]foo() { try { throw "foo"} catch { } } }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C { [int]foo() { try { throw "foo"} catch [ArgumentException] {} catch {throw $_} } }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C { [int]foo() { try { throw "foo"} catch [ArgumentException] {return 1} catch {} } }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C { [int]foo() { while ($false) { return 1 } } }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C { [int]foo() { try { New-Item -ItemType Directory foo } finally { rm -rec foo } } }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C { [int]foo() { try { New-Item -ItemType Directory foo; return 1 } catch { } } }' MethodHasCodePathNotReturn 15
    ShouldBeParseError 'class C { [bool] Test() { if ($false) { return $true; } } }' MethodHasCodePathNotReturn 17

    ShouldBeParseError 'class C { [int]$i; [void] foo() {$i = 10} }' MissingThis 33
    ShouldBeParseError 'class C { static [int]$i; [void] foo() {$i = 10} }' MissingTypeInStaticPropertyAssignment 40

    ShouldBeParseError 'class C : B' MissingTypeBody 11

    ShouldBeParseError 'Class foo { q(){} w(){}' MissingEndCurlyBrace 11
}

Describe 'Negative methods Tests' -Tags "CI" {
    ShouldBeParseError 'class foo { f() { param($x) } }' ParamBlockNotAllowedInMethod 18
    ShouldBeParseError 'class foo { f() { dynamicparam {} } }' NamedBlockNotAllowedInMethod 18
    ShouldBeParseError 'class foo { f() { begin {} } }' NamedBlockNotAllowedInMethod 18
    ShouldBeParseError 'class foo { f() { process {} } }' NamedBlockNotAllowedInMethod 18
    ShouldBeParseError 'class foo { f() { end {} } }' NamedBlockNotAllowedInMethod 18
    ShouldBeParseError 'class foo { f([Parameter()]$a) {} }' AttributeNotAllowedOnDeclaration 14
    ShouldBeParseError 'class foo { [int] foo() { return 1 }}' ConstructorCantHaveReturnType 12
    ShouldBeParseError 'class foo { [void] bar($a, [string][int]$b, $c) {} }' MultipleTypeConstraintsOnMethodParam 35
}

Describe 'Negative Assignment Tests' -Tags "CI" {
    ShouldBeParseError 'class foo { [string ]$path; f() { $path="" } }' MissingThis 34
    ShouldBeParseError 'class foo { [string ]$path; f() { [string] $path="" } }' MissingThis 43
    ShouldBeParseError 'class foo { [string ]$path; f() { [int] [string] $path="" } }' MissingThis 49
}

Describe 'Negative Assignment Tests' -Tags "CI" {
    ShouldBeParseError '[DscResource()]class C { [bool] Test() { return $false } [C] Get() { return $this } Set() {} }' DscResourceMissingKeyProperty 0

    # Test method
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [C] Get() { return $this } Set() {} }' DscResourceMissingTestMethod 0
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [C] Get() { return $this } Set() {} Test() { } }' DscResourceMissingTestMethod 0
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [C] Get() { return $this } Set() {} [int] Test() { return 1 } }' DscResourceMissingTestMethod 0
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [C] Get() { return $this } Set() {} [bool] Test($a) { return $false } }' DscResourceMissingTestMethod 0

    # Get method
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } Set() {} }' DscResourceMissingGetMethod 0
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } Set() {} Get() { } }' DscResourceInvalidGetMethod 98
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } Set() {} [int] Get() { return 1 } }' DscResourceInvalidGetMethod 98
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } Set() {} [C] Get($a) { return $this } }' DscResourceMissingGetMethod 0

    # Set method
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } [C] Get() { return $this } }' DscResourceMissingSetMethod 0
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } [C] Get() { return $this } [int] Set() { return 1 } }' DscResourceMissingSetMethod 0
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } [C] Get() { return $this } Set($a) { } }' DscResourceMissingSetMethod 0

    # Default ctor
    ShouldBeParseError '[DscResource()]class C { [DscProperty(Key)][string]$Key; [bool] Test() { return $false } [C] Get() { return $this } Set() {} C($a) { } }' DscResourceMissingDefaultConstructor 0
}

Describe 'Negative DscResources Tests' -Tags "CI" {
        # Usage errors
        ShouldBeParseError '[Flags()]class C{}' AttributeNotAllowedOnDeclaration 0
        ShouldBeParseError 'class C { [Flags()]$field; }' AttributeNotAllowedOnDeclaration 10
        ShouldBeParseError 'class C { [Flags()]foo(){} }' AttributeNotAllowedOnDeclaration 10

        # Errors related to construction of the attribute
        ShouldBeParseError '[UnknownAttr()]class C{}' CustomAttributeTypeNotFound 1
        ShouldBeParseError '[System.Management.Automation.Cmdlet()]class C{}' MethodCountCouldNotFindBest 0 -SkipAndCheckRuntimeError
        ShouldBeParseError '[System.Management.Automation.Cmdlet("zz")]class C{}' MethodCountCouldNotFindBest 0 -SkipAndCheckRuntimeError
        ShouldBeParseError '[System.Management.Automation.Cmdlet("Get", "Thing", Prop=1)]class C{}' PropertyNotFoundForAttribute 53
        ShouldBeParseError '[System.Management.Automation.Cmdlet("Get", "Thing", ConfirmImpact="foo")]class C{}' CannotConvertValue 67 -SkipAndCheckRuntimeError
        ShouldBeParseError '[System.Management.Automation.Cmdlet("Get", "Thing", NounName="foo")]class C{}' ReadOnlyProperty 53
        ShouldBeParseError '[System.Management.Automation.Cmdlet("Get", "Thing", ConfirmImpact=$zed)]class C{}' ParameterAttributeArgumentNeedsToBeConstant 67
        ShouldBeParseError 'class C{ [ValidateScript({})]$p; }' ParameterAttributeArgumentNeedsToBeConstant 25
}

Describe 'Negative ClassAttributes Tests' -Tags "CI" {
    [System.Management.Automation.Cmdlet("Get", "Thing")]class C{}
    $t = [C].GetCustomAttributes($false)

    It "Should have one attribute (class C)" {$t.Count | Should -Be 1}
    It "Should have instance of CmdletAttribute (class C)" {$t[0] | Should -BeOfType System.Management.Automation.CmdletAttribute }

    [System.Management.Automation.CmdletAttribute]$c = $t[0]
    It "Verb should be Get (class C)" {$c.VerbName | Should -BeExactly 'Get'}
    It "Noun should be Thing (class C)" {$c.NounName | Should -BeExactly 'Thing'}

    [System.Management.Automation.Cmdlet("Get", "Thing", SupportsShouldProcess = $true, SupportsPaging = $true)]class C2{}
    $t = [C2].GetCustomAttributes($false)
    It "Should have one attribute (class C2)" { $t.Count | Should -Be 1 }
    It "Should have instance of CmdletAttribute (class C2)" { $t[0] | Should -BeOfType System.Management.Automation.CmdletAttribute }
    [System.Management.Automation.CmdletAttribute]$c = $t[0]
    It "Verb should be Get (class C2)" {$c.VerbName | Should -BeExactly 'Get'}
    It "Noun should be Thing (class C2)" {$c.NounName | Should -BeExactly 'Thing'}

    It  "SupportsShouldProcess should be $true" { $c.SupportsShouldProcess | Should -BeTrue }
    It  "SupportsPaging should be `$true" { $c.SupportsPaging | Should -BeTrue }
    Context "Support ConfirmImpact as an attribute" {
        It  "ConfirmImpact should be high" {
            [System.Management.Automation.Cmdlet("Get", "Thing", SupportsShouldProcess = $true, ConfirmImpact = 'High', SupportsPaging = $true)]class C3{}
            $t = [C3].GetCustomAttributes($false)
            $t.Count | Should -Be 1
            $t[0] | Should -BeOfType System.Management.Automation.CmdletAttribute
            [System.Management.Automation.CmdletAttribute]$c = $t[0]
            $c.ConfirmImpact | Should -BeExactly 'High'

        }
    }
}

Describe 'Property Attributes Test' -Tags "CI" {
        class C { [ValidateSet('a', 'b')]$p; }

        $t = [C].GetProperty('p').GetCustomAttributes($false)
        It "Should have one attribute" { $t.Count | Should -Be 1 }
        [ValidateSet]$v = $t[0]
        It "Should have 2 valid values" { $v.ValidValues.Count | Should -Be 2 }
        It "first value should be a" { $v.ValidValues[0] | Should -Be 'a' }
        It "second value should be b" { $v.ValidValues[1] | Should -Be 'b' }
}

Describe 'Testing Method Names can be Keywords' -Tags "CI" {
    BeforeAll {
        [powershell] $script:PowerShell = [powershell]::Create()

        function Invoke-PowerShell {
            [CmdletBinding()]
            param([string] $Script)

            try {
                $script:PowerShell.AddScript($Script).Invoke()
            }
            finally {
                $script:PowerShell.Commands.Clear()
            }
        }

        function Reset-PowerShell {
            if ($script:PowerShell) {
                $script:PowerShell.Dispose()
            }

            $script:PowerShell = [powershell]::Create()
        }
    }

    AfterEach {
        Reset-PowerShell
    }

    It 'Permits class methods to be named after keywords' {
        $TestScript = @'
            class TestMethodNames : IDisposable {
                [string] Begin() { return "Begin" }

                [string] Process() { return "Process" }

                [string] End() { return "End" }

                hidden $Data = "Secrets"

                Dispose() {
                    $this.Data = [string]::Empty
                }
            }
            $Object = [TestMethodNames]::new()
            [PSCustomObject]@{
                BeginTest   = $Object.Begin()
                ProcessTest = $Object.Process()
                EndTest     = $Object.End()
                CheckData1  = $Object.Data
                CheckData2  = $( $Object.Dispose(); $Object.Data )
            }
'@
        $Results = Invoke-PowerShell -Script $TestScript

        $Results.BeginTest | Should -BeExactly 'Begin'
        $Results.ProcessTest | Should -BeExactly 'Process'
        $Results.EndTest | Should -BeExactly 'End'
        $Results.CheckData1 | Should -BeExactly 'Secrets'
        $Results.CheckData2 | Should -BeNullOrEmpty
    }

    It 'Permits class methods to be named after DynamicKeywords' {
        $DefineKeyword = @'
            function GetData {
                param(
                    $KeywordData,
                    $Name,
                    $Value,
                    $SourceMetadata
                )
                end {
                    return $PSBoundParameters
                }
            }

            $keyword = [System.Management.Automation.Language.DynamicKeyword]::new()
            $keyword.NameMode = [System.Management.Automation.Language.DynamicKeywordNameMode]::SimpleNameRequired
            $keyword.Keyword = 'GetData'
            $keyword.BodyMode = [System.Management.Automation.Language.DynamicKeywordBodyMode]::Hashtable

            $property = [System.Management.Automation.Language.DynamicKeywordProperty]::new()
            $property.Name = 'Hey'
            $property.TypeConstraint = 'int'
            $keyword.Properties.Add('Hey', $property)

            [System.Management.Automation.Language.DynamicKeyword]::AddKeyword($keyword)
'@
        $DefineClass = @'
            class Test {
                hidden $Data = 'TOP SECRET'

                [string] GetData() {
                    return $this.Data
                }
            }
'@
        $TestScript = @'
            $Object = [Test]::new()
            $Object.GetData()
'@
        Invoke-PowerShell -Script $DefineKeyword
        Invoke-PowerShell -Script $DefineClass

        Invoke-PowerShell -Script $TestScript | Should -BeExactly 'TOP SECRET'
    }

    AfterAll {
        # Ensure we don't leave any dynamic keywords in the session.
        [System.Management.Automation.Language.DynamicKeyword]::Reset()
    }
}

Describe 'Method Attributes Test' -Tags "CI" {
        class C { [Obsolete("aaa")][int]f() { return 1 } }

        $t = [C].GetMethod('f').GetCustomAttributes($false)
        It "Should have one attribute" {$t.Count | Should -Be 1 }
        It "Attribute type should be ObsoleteAttribute" { $t[0].GetType().FullName | Should -Be System.ObsoleteAttribute }
}

Describe 'Positive SelfClass Type As Parameter Test' -Tags "CI" {
        class Point
        {
            Point($x, $y) { $this.x = $x; $this.y = $y }
            Point() {}

            [int] $x = 0
            [int] $y = 0
            Add([Point] $val) {  $this.x += $val.x; $this.y += $val.y;  }

            Print() { Write-Host "[`$x=$($this.x) `$y=$($this.y)]" }
            Set($x, $y) { $this.x = $x; $this.y = $y }
        }
        It  "[Point]::Add works construction via ::new" {
            $point = [Point]::new(100,200)
            $point2 = [Point]::new(1,2)
            $point.Add($point2)

            $point.x | Should -Be 101
            $point.y | Should -Be 202
        }

        It  "[Point]::Add works construction via new-object" {
            $point = New-Object Point 100,200
            $point2 = New-Object Point 1,2
            $point.Add($point2)

            $point.x | Should -Be 101
            $point.y | Should -Be 202
        }
}

Describe 'PositiveReturnSelfClassTypeFromMemberFunction Test' -Tags "CI" {
        class ReturnObjectFromMemberFunctionTest
        {
            [ReturnObjectFromMemberFunctionTest] CreateInstance()
            {
              return [ReturnObjectFromMemberFunctionTest]::new()
            }
            [string] SayHello()
            {
                return "Hello1"
            }
        }
        $f = [ReturnObjectFromMemberFunctionTest]::new()
        $z = $f.CreateInstance() # Line 13
        It "CreateInstance works" { $z.SayHello() | Should -BeExactly 'Hello1' }
}

Describe 'TestMultipleArguments Test' -Tags "CI" {
        if ( $IsCoreCLR ) { $maxCount = 14 } else { $maxCount = 16 }
        for ($i = 0; $i -lt $maxCount; $i++)
        {
            $properties = $(for ($j = 0; $j -le $i; $j++) {
                "        [int]`$Prop$j"
            }) -join "`n"

            $methodParameters = $(for ($j = 0; $j -le $i; $j++) {
                "[int]`$arg$j"
            }) -join ", "

            $ctorAssignments = $(for ($j = 0; $j -le $i; $j++) {
                "            `$this.Prop$j = `$arg$j"
            }) -join "`n"

            $methodReturnValue = $(for ($j = 0; $j -le $i; $j++) {
                "`$arg$j"
            }) -join " + "

            $methodArguments =  $(for ($j = 0; $j -le $i; $j++) {
                $j
            }) -join ", "

            $addUpProperties =  $(for ($j = 0; $j -le $i; $j++) {
                "`$inst.`Prop$j"
            }) -join " + "

            $expectedTotal = (0..$i | Measure-Object -Sum).Sum

            $class = @"
    class Foo
    {
$properties

        Foo($methodParameters)
        {
$ctorAssignments
        }

        [int] DoSomething($methodParameters)
        {
            return $methodReturnValue
        }
    }

    `$inst = [Foo]::new($methodArguments)
    `$sum = $addUpProperties
    It "ExpectedTotal: Sum should be $expectedTotal" { `$sum | Should -Be $expectedTotal }
    It "ExpectedTotal: Invocation should return $expectedTotal" { `$inst.DoSomething($methodArguments) | Should -Be $expectedTotal }
"@

            Invoke-Expression $class
        }
}

Describe 'Scopes Test' -Tags "CI" {
        class C1
        {
            static C1() {
                $global:foo = $script:foo
            }
            C1() {
                $script:bar = $global:foo
            }
            static [int] f1() {
                return $script:bar + $global:bar
            }
            [int] f2() {
                return $script:bar + $global:bar
            }
        }
}

Describe 'Check PS Class Assembly Test' -Tags "CI" {
        class C1 {}
        $assem = [C1].Assembly
        $attrs = @($assem.GetCustomAttributes($true))
        $expectedAttr = @($attrs | Where-Object { $_  -is [System.Management.Automation.DynamicClassImplementationAssemblyAttribute] })
        It "Expected a DynamicClassImplementationAssembly attribute" { $expectedAttr.Length | Should -Be 1}
}

Describe 'ScriptScopeAccessFromClassMethod' -Tags "CI" {
        Import-Module "$PSScriptRoot\MSFT_778492.psm1"
        try
        {
            $c = Get-MSFT_778492
            It "Method should have found variable in module scope" { $c.F() | Should -BeExactly 'MSFT_778492 script scope'}
        }
        finally
        {
            Remove-Module MSFT_778492
        }
}

Describe 'Hidden Members Test ' -Tags "CI" {
        class C1
        {
            [int]$visibleX
            [int]$visibleY
            hidden [int]$hiddenZ
        }

        # Create an instance
        $instance = [C1]@{ visibleX = 10; visibleY = 12; hiddenZ = 42 }

        It "Access hidden property should still work" { $instance.hiddenZ | Should -Be 42 }

        It "Table formatting should not include hidden member hiddenZ" {
            $expectedTable = @"

visibleX visibleY
-------- --------
      10       12


"@

            $tableOutput = $instance | Format-Table -AutoSize | Out-String
            $tableOutput.Replace("`r","") | Should -BeExactly $expectedTable.Replace("`r","")
        }

        # Get-Member should not include hidden members by default
        $member = $instance | Get-Member hiddenZ
        It "Get-Member should not find hidden member w/o -Force" { $member | Should -BeNullOrEmpty }

        # Get-Member should include hidden members with -Force
        $member = $instance | Get-Member hiddenZ -Force
        It "Get-Member should find hidden member w/ -Force" { $member | Should -Not -BeNullOrEmpty }

        # Tab completion should not return a hidden member
        $line = 'class C2 { hidden [int]$hiddenZ } [C2]::new().h'
        $completions = [System.Management.Automation.CommandCompletion]::CompleteInput($line, $line.Length, $null)
        It "Tab completion should not return a hidden member" { $completions.CompletionMatches.Count | Should -Be 0 }
}

Describe 'BaseMethodCall Test ' -Tags "CI" {
        It "Derived class method call" {"abc".ToString() | Should -BeExactly "abc" }
        # call [object] ToString() method as a base class method.
        It "Base class method call" {([object]"abc").ToString() | Should -BeExactly "System.String" }
}

Describe 'Scoped Types Test' -Tags "CI" {
        class C1 { [string] GetContext() { return "Test scope" } }

        filter f1
        {
            class C1 { [string] GetContext() { return "f1 scope" } }

            return [C1]::new().GetContext()
        }

        filter f2
        {
            class C1 { [string] GetContext() { return "f2 scope" } }

            return (New-Object C1).GetContext()
        }

        It "New-Object at test scope" { (New-Object C1).GetContext() | Should -BeExactly "Test scope" }
        It "[C1]::new() at test scope" { [C1]::new().GetContext() | Should -BeExactly "Test scope" }

        It "[C1]::new() in nested scope" { (f1) | Should -BeExactly "f1 scope" }
        It "'new-object C1' in nested scope" { (f2) | Should -BeExactly "f2 scope" }

        It "[C1]::new() in nested scope (in pipeline)" { (1 | f1 | f2 | f1) | Should -BeExactly "f1 scope" }
        It "'new-object C1' in nested scope (in pipeline)" { (1 | f2 | f1 | f2) | Should -BeExactly "f2 scope" }
}

Describe 'ParameterOfClassTypeInModule Test' -Tags "CI" {
        try
        {
            $sb = [scriptblock]::Create(@'
enum EE {one = 1}
function test-it([EE]$ee){$ee}
'@)
            $mod = New-Module $sb -Name MSFT_2081529 | Import-Module
            $result = test-it -ee one
            It "Parameter of class/enum type defined in module should work" { $result | Should -Be 1 }
        }
        finally
        {
            Remove-Module -ErrorAction ignore MSFT_2081529
        }
}

Describe 'Type building' -Tags "CI" {
    It 'should build the type only once for scriptblock' {
        $a = $null
        1..10 | ForEach-Object {
            class C {}
            if ($a) {
	         $a -eq [C] | Should -BeTrue
            }
            $a = [C]
        }
    }

    It 'should create a new type every time scriptblock executed?' -Pending {
        $sb = [scriptblock]::Create('class A {static [int] $a }; [A]::new()')
        1..2 | ForEach-Object {
        $a = $sb.Invoke()[0]
            ++$a::a | Should -Be 1
            ++$a::a | Should -Be 2
        }
    }

    It 'should get the script from a class type' {
        class C {}

        $a = [C].Assembly.GetCustomAttributes($false).Where{
            $_ -is [System.Management.Automation.DynamicClassImplementationAssemblyAttribute]}
        $a.ScriptFile | Should -BeExactly $PSCommandPath
    }
}

Describe 'RuntimeType created for TypeDefinitionAst' -Tags "CI" {

    It 'can make cast to the right RuntimeType in two different contexts' -Pending {

        $ssfe = [System.Management.Automation.Runspaces.SessionStateFunctionEntry]::new("foo", @'
class Base
{
    [int] foo() { return 100 }
}

class Derived : Base
{
    [int] foo() { return 2 * ([Base]$this).foo() }
}

[Derived]::new().foo()
'@)

        $iss = [System.Management.Automation.Runspaces.initialsessionstate]::CreateDefault2()
        $iss.Commands.Add($ssfe)

        $ps = [powershell]::Create($iss)
        $ps.AddCommand("foo").Invoke() | Should -Be 200
        $ps.Streams.Error | Should -BeNullOrEmpty

        $ps1 = [powershell]::Create($iss)
        $ps1.AddCommand("foo").Invoke() | Should -Be 200
        $ps1.Streams.Error | Should -BeNullOrEmpty

        $ps.Commands.Clear()
        $ps.Streams.Error.Clear()
        $ps.AddScript(". foo").Invoke() | Should -Be 200
        $ps.Streams.Error | Should -BeNullOrEmpty
    }
}

Describe 'TypeTable lookups' -Tags "CI" {

    Context 'Call methods from a different thread' {
        $b = [powershell]::Create().AddScript(
@'
class A {}
class B
{
    [object] getA1() { return New-Object A }
    [object] getA2() { return [A]::new() }
}

[B]::new()

'@).Invoke()[0]

        It 'can do type lookup by name' {
            $b.getA1() | Should -BeExactly 'A'
        }

        It 'can do type lookup by [type]' {
            $b.getA2() | Should -BeExactly 'A'
        }
    }
}

Describe 'Protected method access' -Tags "CI" {

    Add-Type @'
namespace Foo
{
    public class Bar
    {
        protected int x {get; set;}
    }
}
'@

     It 'doesn''t allow protected methods access outside of inheritance chain' {
        $a = [scriptblock]::Create(@'
class A
{
    SetX([Foo.Bar]$bar, [int]$x)
    {
        $bar.x = $x
    }

    [int] GetX([Foo.Bar]$bar)
    {
        Set-StrictMode -Version 3.0
        return $bar.x
    }
}
[A]::new()

'@).Invoke()
        $bar = [Foo.Bar]::new()
        { $a.SetX($bar, 42) } | Should -Throw -ErrorId 'PropertyAssignmentException'
        { $a.GetX($bar) } | Should -Throw -ErrorId 'PropertyNotFoundStrict'
     }

     It 'can call protected methods sequentially from two different contexts' {
        $ssfe = [System.Management.Automation.Runspaces.SessionStateFunctionEntry]::new("foo", @'
class A : Foo.Bar
{
    SetX([int]$x)
    {
        $this.x = $x
    }

    [int] GetX()
    {
        return $this.x
    }
}
return [A]::new()
'@)

        $iss = [System.Management.Automation.Runspaces.initialsessionstate]::CreateDefault()
        $iss.Commands.Add($ssfe)

        $ps = [powershell]::Create($iss)
        $a = $ps.AddCommand("foo").Invoke()[0]
        $ps.Streams.Error | Should -BeNullOrEmpty

        $ps1 = [powershell]::Create($iss)
        $a1 = $ps1.AddCommand("foo").Invoke()[0]
        $ps1.Streams.Error | Should -BeNullOrEmpty

        $a.SetX(101)
        $a1.SetX(103)

        $a.GetX() | Should -Be 101
        $a1.GetX() | Should -Be 103
    }
}

Describe 'variable analysis' -Tags "CI" {
    It 'can specify type construct on the local variables' {
        class A { [string] getFoo() { return 'foo'} }

        class B
        {
            static [A] getA ()
            {
                [A] $var = [A]::new()
                return $var
            }
        }

        [B]::getA().getFoo() | Should -BeExactly 'foo'
    }
}
