type B1 interface {
	_() // ERROR "methods must have a unique non-blank name"
}

type B2 interface {
	M()
	_() // ERROR "methods must have a unique non-blank name"
}

type T2 struct{}

func (t *T2) M() {}
func (t *T2) _() {}

// Already reported about the invalid blank interface method above;
// no need to report about not implementing it.
var b1 B1 = &T2{}

import org.gradle.exemplar.executor.ExecutionMetadata
import org.gradle.exemplar.test.normalizer.OutputNormalizer

import java.util.regex.Pattern

/**
 * Allows a blank empty line in your sample output to match a blank line with any number of spaces in the actual output.
 *
 * This exists to avoid having to measure out "prefix" whitespace indentation and match it exactly in your sample output.
 */

= vendor/github.com/blang/semver/v4 licensed under: =

The MIT License

Copyright (c) 2014 Benedikt Lang <github at benediktlang.de>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

        'Name'        | _
        'nAme'        | _
        'naMe'        | _
        'namE'        | _
        'NamE'        | _
    }

    def "demonstrate Java vs. Ant Manifest classes behavior wrt. blank lines"() {
        given:
        TestFile noBlankLinesManifestFile = tmpDir.file('noBlankLinesManifestFile')
        TestFile blankLinesManifestFile = tmpDir.file('blankLinesManifestFile')

		t.Errorf("Update a filed with a default value should occur. But got %v\n", animal.Name)
	}

	// When changing a field with a default value with blank value
	animal.Name = ""
	DB.Save(&animal)
	DB.First(&animal, animal.Counter)
	if animal.Name != "" {
		t.Errorf("Update a filed to blank with a default value should occur. But got %v\n", animal.Name)
	}

type _[P <-chan int] struct{}
type _[P *T | struct{} | T] struct{}

// a trailing comma always indicates a (possibly invalid) type parameter list (blank after type parameter list and type)
type _[P *T,] struct{}
type _[P *T | T,] struct{}
type _[P *T | <-T | T,] struct{}

// slice/array type declarations (no blank between array length and element type)
type _ []byte
type _ [n]byte
type _ [P(T)]byte
type _ [P((T))]byte
type _ [P * *T]byte

type _[P <-chan int] struct{}
type _[P *T | struct{} | T] struct{}

// a trailing comma always indicates a (possibly invalid) type parameter list (blank after type parameter list and type)
type _[P *T,] struct{}
type _[P *T | T,] struct{}
type _[P *T | <-T | T,] struct{}

// slice/array type declarations (no blank between array length and element type)
type _ []byte
type _ [n]byte
type _ [P(T)]byte
type _ [P((T))]byte
type _ [P * *T]byte

//
// The encoded form is the record ID as a single number,
// then the text of the record, and then a terminating blank line.
// Record text must be valid UTF-8 and must not contain any ASCII control
// characters (those below U+0020) other than newline (U+000A).
// It must end in a terminating newline and not contain any blank lines.
func FormatRecord(id int64, text []byte) (msg []byte, err error) {
	if !isValidRecordText(text) {

// The handler may wish to report an error. In this case, pos is the
// current parser position, not the position of the pragma itself.
// Blank specifies whether the line is blank before the pragma.
type PragmaHandler func(pos Pos, blank bool, text string, current Pragma) Pragma

// Parse parses a single Go source file from src and returns the corresponding

import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test


class LinePreservingSubstringTest {

    @Test
    fun `given a range starting after the first line, it should return a substring prefixed by blank lines`() {
        val original = """
            // line 1
            // line 2
            buildscript {
                // line 4
            }
        """.replaceIndent()