Coverage for tests/test_dtd/test_go.py: 100%

1"""Tests for Data Transformation Density (Go)."""

2

3 from analyzers.go import analyze_source

4

5

6 def _dtd(code: str) -> int:

7 """Return DTD of the first function in code."""

8 result = analyze_source(code)

9 assert result.functions, f"No functions found in:\n{code}"

10 return result.functions[0].dtd

11

12

13 def _dtds(code: str) -> dict[str, int]:

14 """Return {name: dtd} for all functions in code."""

15 result = analyze_source(code)

16 return {f.name: f.dtd for f in result.functions}

17

18

19# --- Empty ---

20

21 def test_empty_function():

22 code = "package main\nfunc f() {}"

23 assert _dtd(code) == 0

24

25

26# --- Struct literal ---

27

28 def test_struct_literal():

29 code = """

30 package main

31

32 type Point struct {

33 X int

34 Y int

35}

36

37 func f() Point {

38 return Point{X: 1, Y: 2}

39}

40"""

41 # composite_literal at depth 1, 2 keyed_elements x 1 = 2

42 assert _dtd(code) == 2

43

44

45# --- Slice literal ---

46

47 def test_slice_literal():

48 code = """

49 package main

50

51 func f() []int {

52 return []int{1, 2, 3}

53}

54"""

55 # composite_literal at depth 1, 3 literal_elements x 1 = 3

56 assert _dtd(code) == 3

57

58

59# --- Map literal ---

60

61 def test_map_literal():

62 code = """

63 package main

64

65 func f() map[string]int {

66 return map[string]int{"a": 1, "b": 2}

67}

68"""

69 # composite_literal at depth 1, 2 keyed_elements x 1 = 2

70 assert _dtd(code) == 2

71

72

73# --- Nested composite ---

74

75 def test_nested_composite():

76 code = """

77 package main

78

79 type Inner struct {

80 Value int

81}

82

83 type Outer struct {

84 Items []Inner

85}

86

87 func f() Outer {

88 return Outer{

89 Items: []Inner{

90 Inner{Value: 1},

91 Inner{Value: 2},

92 },

93 }

94}

95"""

96 # Outer composite at depth 1: keyed_element "Items: ..." -> 1

97 # []Inner{} composite at depth 2 (nested in the value of the keyed_element)

98 # 2 literal_elements at depth 2 -> 4

99 # Each Inner{} composite at depth 3: keyed_element at depth 3 -> 3 each -> 6

100 # total = 1 + 4 + 6 = 11

101 assert _dtd(code) == 11

102

103

104# --- Nested named closure ---

105

106 def test_nested_named_closure():

107 code = """

108 package main

109

110 func outer() {

111 x := map[string]int{"a": 1}

112 inner := func() {

113 y := []int{1, 2, 3}

114 }

115 _ = inner

116 _ = x

117}

118"""

119 dtds = _dtds(code)

120 assert dtds["outer"] == 1 # only map[string]int{"a": 1} -> 1 keyed_element x 1

121 assert dtds["inner"] == 3 # []int{1, 2, 3} -> 3 literal_elements x 1