File size: 6,517 Bytes
a70a778
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
import unittest

import torch
from transformers import RobertaConfig

from modeling_vulfixminer import (
    EmptyCommitError,
    VulFixMinerConfig,
    VulFixMinerModel,
    extract_file_diffs,
    get_code_version,
    prepare_commit,
)
from tests.fixtures import DIFF


class PreprocessingTests(unittest.TestCase):
    def test_file_order_and_header_exclusion(self):
        files = extract_file_diffs(DIFF)
        self.assertEqual(list(files), ["a.c", "b.c"])
        self.assertTrue(all(value.startswith("@@") for value in files.values()))
        self.assertEqual(
            prepare_commit(DIFF, "</s>"),
            [
                "fixed();\n</s>old();\n",
                "safe();\n</s>unsafe();\n",
            ],
        )

    def test_comment_prefixes_and_blank_line_baseline_quirk(self):
        self.assertEqual(get_code_version("+//comment\n+#define X\n+   \n+code", True), "\ncode\n")

    def test_empty_binary_and_comment_only(self):
        for diff in (
            "",
            "ordinary text",
            "diff --git a/a b/a\nBinary files differ",
            "diff --git a/a b/a\n@@ -1 +1 @@\n-// old\n+// new",
        ):
            with self.subTest(diff=diff), self.assertRaises(EmptyCommitError):
                prepare_commit(diff, "</s>")

    def test_multihunk_and_one_sided_change(self):
        diff = "diff --git a/a b/a\n@@ -0,0 +1 @@\n+one\n@@ -2 +3 @@\n+two"
        self.assertEqual(prepare_commit(diff, "</s>"), ["one\ntwo\n</s>"])

    def test_invalid_input_type(self):
        with self.assertRaises(TypeError):
            prepare_commit({}, "</s>")
        with self.assertRaises(ValueError):
            prepare_commit(DIFF, "")


class ConfigTests(unittest.TestCase):
    def test_invalid_lengths_and_dropout(self):
        for length in (0, 1, True, 1.5, 513):
            with self.subTest(length=length), self.assertRaises(ValueError):
                VulFixMinerConfig(max_file_length=length)
        for dropout in (-0.1, 1.1, float("nan"), float("inf"), True, "0.1"):
            with self.subTest(dropout=dropout), self.assertRaises(ValueError):
                VulFixMinerConfig(hidden_dropout_prob=dropout)

    def test_encoder_config_is_copied(self):
        original = RobertaConfig().to_dict()
        config = VulFixMinerConfig(encoder_config=original)
        original["hidden_size"] = 1
        self.assertEqual(config.hidden_size, 768)


class ModelTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        torch.manual_seed(7)
        config = VulFixMinerConfig(
            encoder_config=RobertaConfig(
                vocab_size=32,
                hidden_size=16,
                num_hidden_layers=1,
                num_attention_heads=2,
                intermediate_size=32,
                max_position_embeddings=32,
                type_vocab_size=1,
            ),
            max_file_length=16,
        )
        cls.model = VulFixMinerModel(config).eval()
        cls.inputs = torch.randint(3, 32, (3, 8))
        cls.mask = torch.ones_like(cls.inputs)

    def test_single_commit_matches_reference_reduction(self):
        with torch.inference_mode():
            embeddings = self.model.code_bert(self.inputs, self.mask).last_hidden_state[:, 0, :]
            expected = self.model.out_proj(self.model.linear(embeddings.mean(dim=0, keepdim=True)))
            actual = self.model(self.inputs, self.mask).logits
        torch.testing.assert_close(actual, expected, rtol=0, atol=0)

    def test_multiple_commits_match_independent_predictions(self):
        with torch.inference_mode():
            grouped = self.model(self.inputs, self.mask, commit_ids=torch.tensor([0, 0, 1])).logits
            separate = torch.cat(
                [
                    self.model(self.inputs[:2], self.mask[:2]).logits,
                    self.model(self.inputs[2:], self.mask[2:]).logits,
                ]
            )
        torch.testing.assert_close(grouped, separate)

    def test_chunked_file_encoding(self):
        with torch.inference_mode():
            full = self.model(self.inputs, self.mask).logits
            chunked = self.model(self.inputs, self.mask, file_batch_size=1).logits
        torch.testing.assert_close(full, chunked)

    def test_invalid_grouping(self):
        for ids in ([1, 1, 1], [0, 0, 2], [-1, 0, 0], [0], [0.0, 0.0, 0.0]):
            with self.subTest(ids=ids), self.assertRaises(ValueError):
                self.model(self.inputs, self.mask, commit_ids=ids)

    def test_empty_input_and_invalid_chunk_size(self):
        with self.assertRaises(ValueError):
            self.model(self.inputs[:0])
        with self.assertRaises(ValueError):
            self.model(self.inputs, file_batch_size=0)

    def test_invalid_token_shapes_and_types(self):
        for inputs in (
            None,
            [],
            self.inputs[0],
            self.inputs[:, :0],
            self.inputs.float(),
            torch.zeros(1, 17, dtype=torch.long),
        ):
            with self.subTest(inputs=inputs), self.assertRaises(ValueError):
                self.model(inputs)
        with self.assertRaises(ValueError):
            self.model(self.inputs, attention_mask=self.mask[:1])
        with self.assertRaises(ValueError):
            self.model(self.inputs, token_type_ids=self.inputs[:1])

    def test_invalid_labels_and_unsupported_parameters(self):
        for labels in (
            torch.tensor([2]),
            torch.tensor([-1]),
            torch.tensor([1.0]),
            torch.tensor([0, 1]),
        ):
            with self.subTest(labels=labels), self.assertRaises(ValueError):
                self.model(self.inputs, labels=labels)
        with self.assertRaises(TypeError):
            self.model(self.inputs, unsupported=True)

    def test_token_type_ids_are_forwarded(self):
        with torch.inference_mode():
            expected = self.model(self.inputs, self.mask).logits
            actual = self.model(
                self.inputs, self.mask, token_type_ids=torch.zeros_like(self.inputs)
            ).logits
        torch.testing.assert_close(actual, expected, rtol=0, atol=0)

    def test_loss_and_tuple_output(self):
        with torch.inference_mode():
            output = self.model(self.inputs, labels=torch.tensor([1]))
            result = self.model(self.inputs, return_dict=False)
        self.assertEqual(output.loss.ndim, 0)
        self.assertEqual(result[0].shape, (1, 2))


if __name__ == "__main__":
    unittest.main()