예제 #1
0
    def test_non_contiguous_matches_are_not_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1, query_position=analysis.Token(start=0, end=2))
        m2 = LicenseMatch(rule=r1, query_position=analysis.Token(start=4, end=6))
        m5 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))

        self.assertEqual([m1, m5], detect.filter_matches([m1, m2, m5]))
예제 #2
0
    def test_overlapping_matches_are_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1, query_position=analysis.Token(start=0, end=5))
        same_span = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))
        same_span_too = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))

        test = detect.filter_matches([m1, same_span, same_span_too])
        self.assertEqual([m1, same_span], test)
예제 #3
0
    def test_single_contained_matche_is_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1, query_position=analysis.Token(start=0, end=5))
        contained = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=4))
        m5 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))

        test = detect.filter_matches([m1, contained, m5])
        self.assertEqual([m1, m5], test)
예제 #4
0
    def test_matches_with_same_span_are_filtered_if_licenses_are_the_same2(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1, query_position=analysis.Token(start=0, end=2))
        r2 = Rule(licenses=['gpl', 'apache-2.0'])
        m2 = LicenseMatch(rule=r2, query_position=analysis.Token(start=0, end=2))
        m5 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))

        self.assertEqual([m1, m5], detect.filter_matches([m1, m2, m5]))
예제 #5
0
    def test_non_contiguous_or_overlapping_contained_matches_are_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=2))
        m2 = LicenseMatch(rule=r1, query_position=analysis.Token(start=3, end=6))
        m3 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))
        m4 = LicenseMatch(rule=r1, query_position=analysis.Token(start=0, end=7))
        m5 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))

        self.assertEqual([m4], detect.filter_matches([m1, m2, m3, m4, m5]))
예제 #6
0
    def test_non_contiguous_matches_are_not_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=0, end=2))
        m2 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=4, end=6))
        m5 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=6))

        self.assertEqual([m1, m5], detect.filter_matches([m1, m2, m5]))
예제 #7
0
    def test_matches_with_partially_overlapping_spans_are_merged_if_license_are_the_same(self):
        r1 = Rule(licenses=['apache-1.1'])
        r2 = Rule(licenses=['gpl', 'apache-2.0'])

        m1 = LicenseMatch(rule=r1, query_position=analysis.Token(start=0, end=10))
        m2 = LicenseMatch(rule=r1, query_position=analysis.Token(start=1, end=6))

        m3 = LicenseMatch(rule=r2, query_position=analysis.Token(start=5, end=15))

        self.assertEqual([m1, m3], detect.filter_matches([m1, m2, m3]))
예제 #8
0
    def test_single_contained_matche_is_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=0, end=5))
        contained = LicenseMatch(rule=r1,
                                 query_position=analysis.Token(start=1, end=4))
        m5 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=6))

        test = detect.filter_matches([m1, contained, m5])
        self.assertEqual([m1, m5], test)
예제 #9
0
    def test_matches_with_same_span_are_kept_if_licenses_are_different(self):
        r1 = Rule(licenses=['apache-2.0'])
        m1 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=0, end=2))
        r2 = Rule(licenses=['apache-1.1'])
        m2 = LicenseMatch(rule=r2,
                          query_position=analysis.Token(start=0, end=2))
        m5 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=6))

        self.assertEqual([m1, m2, m5], detect.filter_matches([m1, m2, m5]))
예제 #10
0
    def test_overlapping_matches_are_filtered(self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=0, end=5))
        same_span = LicenseMatch(rule=r1,
                                 query_position=analysis.Token(start=1, end=6))
        same_span_too = LicenseMatch(rule=r1,
                                     query_position=analysis.Token(start=1,
                                                                   end=6))

        test = detect.filter_matches([m1, same_span, same_span_too])
        self.assertEqual([m1, same_span], test)
예제 #11
0
    def test_matches_with_partially_overlapping_spans_are_merged_if_license_are_the_same(
            self):
        r1 = Rule(licenses=['apache-1.1'])
        r2 = Rule(licenses=['gpl', 'apache-2.0'])

        m1 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=0, end=10))
        m2 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=6))

        m3 = LicenseMatch(rule=r2,
                          query_position=analysis.Token(start=5, end=15))

        self.assertEqual([m1, m3], detect.filter_matches([m1, m2, m3]))
예제 #12
0
    def test_non_contiguous_or_overlapping_contained_matches_are_filtered(
            self):
        r1 = Rule(licenses=['apache-2.0', 'gpl'])
        m1 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=2))
        m2 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=3, end=6))
        m3 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=6))
        m4 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=0, end=7))
        m5 = LicenseMatch(rule=r1,
                          query_position=analysis.Token(start=1, end=6))

        self.assertEqual([m4], detect.filter_matches([m1, m2, m3, m4, m5]))