* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.plugins.ide.eclipse.model;


import nl.jqno.equalsverifier.EqualsVerifier
import nl.jqno.equalsverifier.Warning
import org.gradle.plugins.ide.eclipse.model.internal.DefaultResourceFilterMatcher
import spock.lang.Specification

public class ResourceFilterMatcherTest extends Specification {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.plugins.ide.eclipse.model;


import nl.jqno.equalsverifier.EqualsVerifier
import nl.jqno.equalsverifier.Warning
import org.gradle.plugins.ide.eclipse.model.internal.DefaultResourceFilter
import org.gradle.plugins.ide.eclipse.model.internal.DefaultResourceFilterMatcher

		xv[i] = Value{}
	}
	nb := sort.Search(len(c.blocks), func(i int) bool { return c.blocks[i].ID == 0 })
	xb := c.blocks[:nb]
	for i := range xb {
		xb[i] = Block{}
	}
	nl := sort.Search(len(c.locs), func(i int) bool { return c.locs[i] == nil })
	xl := c.locs[:nl]
	for i := range xl {
		xl[i] = nil
	}

	// regalloc sets the length of c.regallocValues to whatever it may use,
	// so clear according to length.

	// and switch into that mode if so. This is a violation of the spec,
	// but occurs in practice.
	if r.partsRead == 0 && len(rest) == 1 && rest[0] == '\n' {
		r.nl = r.nl[1:]
		r.nlDashBoundary = r.nlDashBoundary[1:]
	}
	return bytes.Equal(rest, r.nl)
}

// skipLWSPChar returns b with leading spaces and tabs removed.
// RFC 822 defines:
//
//	LWSP-char = SPACE / HTAB
func skipLWSPChar(b []byte) []byte {

	peek2 := s
	if p.para() == nil && peek2.trimSpace(4, 4, false) && !peek2.isBlank() {
		b := &preBuilder{ /*indent: strings.TrimSuffix(s.string(), peek2.string())*/ }
		p.addBlock(b)
		p.corner = p.corner || peek2.nl != '\n' // goldmark does not normalize to \n
		b.text = append(b.text, peek2.string())
		return line{}, true
	}
	return s, false
}

func newFence(p *parseState, s line) (line, bool) {
	var fence, info string

 */

package jcifs.smb1.util;

import java.io.OutputStream;
import java.io.PrintStream;

/**
 */

public class Hexdump {

    private static final String NL = System.getProperty( "line.separator" );
    private static final int NL_LENGTH = NL.length();

    private static final char[] SPACE_CHARS = {
        ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',

		family = unix.AF_INET6
	} else {
		family = unix.AF_INET
	}
	err := netlink.IpsetCreate(name, "hash:ip", netlink.IpsetCreateOptions{Comments: true, Replace: true, Family: family})
	if ipsetErr, ok := err.(nl.IPSetError); ok && ipsetErr == nl.IPSET_ERR_EXIST {
		return nil
	}

	return err
}

func (m *realDeps) destroySet(name string) error {
	err := netlink.IpsetDestroy(name)
	return err
}

			if isddd {
				if i >= len(nl) {
					goto notenough
				}
				if len(nl)-i > 1 {
					goto toomany
				}
				n = nl[i]
				ir.SetPos(n)
				if n.Type() != nil {
					nl[i] = assignconvfn(n, t, desc)
				}
				return
			}

			// TODO(mdempsky): Make into ... call with implicit slice.
			for ; i < len(nl); i++ {
				n = nl[i]
				ir.SetPos(n)

	if err != nil {
		return
	}

	n, err = l.out.Write(nl)
	if err != nil {
		return
	}

	return l.Write(b[excess:])
}

func (l *lineBreaker) Close() (err error) {
	if l.used > 0 {
		_, err = l.out.Write(l.line[0:l.used])
		if err != nil {
			return
		}
		_, err = l.out.Write(nl)
	}

	return
}

func writeHeader(out io.Writer, k, v string) error {

	flags uint16

	// data holds netlink attributes.
	data []nl.NetlinkRequestData

	// response and err are the predefined output of execution.
	response [][]byte
	err      error
}

// Serialize is part of request interface.
func (fr *fakeRequest) Serialize() []byte { return nil }

// AddData is part of request interface.
func (fr *fakeRequest) AddData(data nl.NetlinkRequestData) {
	fr.data = append(fr.data, data)
}