FilesExpand file tree

master

/

StaticTest.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

154 lines (123 loc) · 5.82 KB

master

/

StaticTest.cs

Copy path

Top

File metadata and controls

• Code
• Blame

154 lines (123 loc) · 5.82 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

/* ****************************************************************************

*

* Copyright (c) Microsoft Corporation.

*

* This source code is subject to terms and conditions of the Apache License, Version 2.0. A

* copy of the license can be found in the License.html file at the root of this distribution. If

* you cannot locate the Apache License, Version 2.0, please send an email to

* ironpy@microsoft.com. By using this source code in any fashion, you are agreeing to be bound

* by the terms of the Apache License, Version 2.0.

*

* You must not remove this notice, or any other, from this software.

*

*

* ***************************************************************************/

using System.Runtime.InteropServices;

namespace IronPythonTest.StaticTest {

public class B { }

public class D : B { }

public delegate string MyEventHandler();

public class Base {

public static string Method_None() { return "Base.Method_None"; }

public static string Method_OneArg(int arg) { return "Base.Method_OneArg"; }

public static string Method_Base(Base arg) { return "Base.Method_Base"; }

public static string Method_Inheritance1(B arg) { return "Base.Method_Inheritance1"; }

public static string Method_Inheritance2(D arg) { return "Base.Method_Inheritance2"; }

public static string Method_Inheritance3(B arg1, D arg2) { return "Base.Method_Inheritance3"; }

public static string Field = "Base.Field";

static string s_for_property = "Base.Property";

public static string Property {

get { return s_for_property; }

set { s_for_property = value; }

}

public static event MyEventHandler Event;

public static string TryEvent() {

if (Event == null) {

return "Still None";

} else {

return Event();

}

}

}

public class OverrideNothing : Base {

}

public class OverrideAll : Base {

public new static string Method_None() { return "OverrideAll.Method_None"; }

public new static string Method_OneArg(int arg) { return "OverrideAll.Method_OneArg"; }

public static string Method_Base(OverrideAll arg) { return "OverrideAll.Method_Base"; }

public static string Method_Inheritance1(D arg) { return "OverrideAll.Method_Inheritance1"; }

public static string Method_Inheritance2(B arg) { return "OverrideAll.Method_Inheritance2"; }

public static string Method_Inheritance3(D arg1, B arg2) { return "OverrideAll.Method_Inheritance3"; }

public new static string Field = "OverrideAll.Field";

static string s_for_property = "OverrideAll.Property";

public new static string Property {

get { return s_for_property; }

set { s_for_property = value; }

}

public new static event MyEventHandler Event;

public new static string TryEvent() {

if (Event == null) {

return "Still None here";

} else {

return Event();

}

}

}

public class GB<T> {

public static string M1(T arg) { return "GB.M1"; }

public static string M2(T arg) { return "GB.M2"; }

public static string M3(T arg) { return "GB.M3"; }

public static string M4() { return "GB.M4-A"; }

public static string M4(ref T arg) { return "GB.M4-B"; }

public static string M21(int arg1, [DefaultParameterValue(100)]int arg2) { return "GB.M21"; }

public static string M22(int arg1) { return "GB.M22"; }

public static string M23([DefaultParameterValue(100)]int arg) { return "GB.M23"; }

public static string M24([DefaultParameterValue(100)]int arg) { return "GB.M24"; }

public static string M25() { return "GB.M25"; }

}

public class GD : GB<string> {

public static string M1(int arg) { return "GD.M1"; }

public static string M2<T>(T arg) { return "GD.M2"; }

public new static string M3(string arg) { return "GD.M3"; }

public static string M4(ref int arg) { return "GD.M4"; }

public static string M21(int arg1) { return "GD.M21"; }

public static string M22(int arg1, [DefaultParameterValue(100)]int arg2) { return "GD.M22"; }

public new static string M23(int arg1) { return "GD.M23"; }

public static string M24() { return "GD.M24"; }

public static string M25([DefaultParameterValue(100)]int arg) { return "GD.M25"; }

}

public class KB {

public static string M1(string arg) { return "KB.M1"; }

}

public class KD<T> : KB {

public static string M1(T arg) { return "KD.M1"; }

}

}

namespace IronPythonTest.StaticTest.Operator {

public class G1<T> {

internal T Field;

public G1(T t) { Field = t; }

}

public class G2<T1, T2> {

public T1 Field1;

public T2 Field2;

public G2(T1 t1, T2 t2) {

Field1 = t1;

Field2 = t2;

}

public static implicit operator G1<T1>(G2<T1, T2> x) { return new G1<T1>(x.Field1); }

public static implicit operator G1<T2>(G2<T1, T2> x) { return new G1<T2>(x.Field2); }

// well, not fit in the test purpose here; but just borrow the place to cover this

public static explicit operator G2<T1, T2>(G1<T1> x) { return new G2<T1, T2>(x.Field, default(T2)); }

public static explicit operator G2<T1, T2>(G1<T2> x) { return new G2<T1, T2>(default(T1), x.Field); }

}

public class SC : G2<int, string> {

public SC(int t1, string t2) : base(t1, t2) { }

}

public class Use {

public object M1(G1<int> x) { return x.Field; }

public object M2(G1<string> x) { return x.Field; }

public object M3(G1<object> x) { return x.Field; }

public object M6(G2<int, string> x) { return x.Field1; }

}

}