FilesExpand file tree

 master

/

java-newInstance.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

126 lines (109 loc) · 3.91 KB

 master

/

java-newInstance.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

126 lines (109 loc) · 3.91 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

import { beforeAll, describe, expect, test } from "vitest";

import { Java, JavaObject } from "../java";

import { getJava } from "../testHelpers";

describe("Java - New Instance", () => {

let java!: Java;

beforeAll(async () => {

java = await getJava();

});

test("newInstance", async () => {

await new Promise<void>((resolve) => {

java.newInstance("Test", (err: Error | undefined, result: JavaObject | undefined) => {

expect(err).toBeFalsy();

expect(result).toBeTruthy();

expect(result.getClassSync().toStringSync()).toBe("class Test");

expect(result.getInt).toBeTruthy();

expect(result.getIntSync).toBeTruthy();

expect(result.staticMethod).toBeFalsy();

expect(result.staticMethodSync).toBeFalsy();

expect(result.nonstaticInt).toBe(42);

resolve();

});

});

});

test("newInstanceSync", () => {

const result = java.newInstanceSync("Test");

expect(result).toBeTruthy();

expect(result.getClassSync().toStringSync()).toBe("class Test");

});

test("newInstance with args", async () => {

await new Promise<void>((resolve) => {

java.newInstance("Test", 42, (err: Error | undefined, result: JavaObject | undefined) => {

expect(err).toBeFalsy();

expect(result).toBeTruthy();

expect(result.getIntSync()).toBe(42);

resolve();

});

});

});

test("newInstanceSync with args", () => {

const result = java.newInstanceSync("Test", 42);

expect(result).toBeTruthy();

expect(result.getIntSync()).toBe(42);

});

test("newInstance bad class name", async () => {

await new Promise<void>((resolve) => {

java.newInstance("BadClassName", (err: Error | undefined, result: JavaObject | undefined) => {

expect(err).toBeTruthy();

expect(result).toBeFalsy();

resolve();

});

});

});

test("newInstanceSync bad class name", () => {

expect(() => {

java.newInstanceSync("BadClassName");

}).toThrow();

});

test("newInstance bad arg types", async () => {

await new Promise<void>((resolve) => {

java.newInstance("Test", "a", (err: Error | undefined, result: JavaObject | undefined) => {

expect(err).toBeTruthy();

expect(result).toBeFalsy();

resolve();

});

});

});

test("newInstanceSync bad arg types", () => {

expect(() => {

java.newInstanceSync("Test", "a");

}).toThrow();

});

test("newInstance bad number of args", async () => {

await new Promise<void>((resolve) => {

java.newInstance("Test", 42, 15, (err: Error | undefined, result: JavaObject | undefined) => {

expect(err).toBeTruthy();

expect(result).toBeFalsy();

resolve();

});

});

});

test("newInstanceSync bad number of args", () => {

expect(() => {

java.newInstanceSync("Test", 42, 15);

}).toThrow();

});

test("newInstance exception thrown from constructor", async () => {

const ex = java.newInstanceSync("java.lang.Exception", "my exception");

await new Promise<void>((resolve) => {

java.newInstance("TestExceptions", ex, (err: Error | undefined, result: JavaObject | undefined) => {

expect(err).toBeTruthy();

expect(err?.toString()).toMatch(/my exception/);

expect(result).toBeFalsy();

resolve();

});

});

});

test("newInstanceSync exception thrown from constructor", () => {

const ex = java.newInstanceSync("java.lang.Exception", "my exception");

expect(() => java.newInstanceSync("TestExceptions", ex)).toThrowError(/my exception/);

});

test("newInstanceSync with varargs", () => {

let result = java.newInstanceSync("Test", 42, java.newArray("java.lang.String", ["a", "b"]));

expect(result).toBeTruthy();

result = java.newInstanceSync("Test", 42, "a");

expect(result).toBeTruthy();

result = java.newInstanceSync("Test", 42, "a", "b", "c");

expect(result).toBeTruthy();

});

});