// Code generated by "stringer -type Action lifecycle.go"; DO NOT EDIT.

package lifecycle

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[NoneAction-0]
	_ = x[DeleteAction-1]
	_ = x[DeleteVersionAction-2]
	_ = x[TransitionAction-3]
	_ = x[TransitionVersionAction-4]

// errorcheck

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type Stringer interface {
	String() string
}

func main() {
	var e interface{}
	switch e := e.(type) {
	case G: // ERROR "undefined: G|undefined type .*G"
		e.M() // ok: this error should be ignored because the case failed its typecheck

// Code generated by "stringer -type=STSErrorCode -trimprefix=Err sts-errors.go"; DO NOT EDIT.

package cmd

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[ErrSTSNone-0]
	_ = x[ErrSTSAccessDenied-1]
	_ = x[ErrSTSMissingParameter-2]
	_ = x[ErrSTSInvalidParameterValue-3]

package main

import (
	"fmt"
	"strconv"
	"strings"
)

type Stringer interface {
	String() string
}

// StringableList is a slice of some type, where the type
// must have a String method.
type StringableList[T Stringer] []T

func (s StringableList[T]) String() string {
	var sb strings.Builder
	for i, v := range s {
		if i > 0 {
			sb.WriteString(", ")
		}

#include <iostream>
#include <windows.h>
#include <string>
#include "hello.h"

std::string LoadStringFromResource(UINT stringID)
{
    HINSTANCE instance = GetModuleHandle("hello");
    WCHAR * pBuf = NULL;
    int len = LoadStringW(instance, stringID, reinterpret_cast<LPWSTR>(&pBuf), 0);
    std::wstring wide = std::wstring(pBuf, len);
    return std::string(wide.begin(), wide.end());
}

void hello() {

var _CSPropBits_index = [...]uint8{0, 14, 33, 51}

func (i CSPropBits) String() string {
	var b bytes.Buffer

	remain := uint64(i)
	seen := false

	for k, v := range _CSPropBits_value {
		x := _CSPropBits_name[_CSPropBits_index[k]:_CSPropBits_index[k+1]]
		if v == 0 {
			if i == 0 {
				b.WriteString(x)
				return b.String()
			}
			continue
		}
		if (v & remain) == v {
			remain &^= v

"""
    }

    @Override
    String getExtraConfiguration(String binaryName) {
        return getExtraConfiguration()
    }

    @Override
    String compilerArgs(String arg) {
        "rcCompiler.args '${arg}'"
    }

    @Override
    String compilerDefine(String define) {
        "rcCompiler.define '${define}'"
    }

    @Override
    String compilerDefine(String define, String value) {

LogicalResult ValidateAttrs(Operation* src, const StringSet<>& registered);

// Copies all the allowed attributes in 'src' to 'dst'. The copy failed if the
// 'dst' has the attribute. Return a failure if there are any attributes are not
// allowed and also unregistered.
LogicalResult CopyAllowedUnregisteredAttrs(Operation* src, CallOp dst,
                                           const StringSet<>& registered);

// Code generated by "stringer -type state"; DO NOT EDIT.

package template

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[stateText-0]
	_ = x[stateTag-1]
	_ = x[stateAttrName-2]
	_ = x[stateAfterName-3]
	_ = x[stateBeforeValue-4]
	_ = x[stateHTMLCmt-5]
	_ = x[stateRCDATA-6]

# See the License for the specific language governing permissions and
# limitations under the License.

import os
import sys
import unittest

from io import StringIO

import boilerplate

class TestBoilerplate(unittest.TestCase):
    """
    Note: run this test from the hack/boilerplate directory.

    $ python -m unittest boilerplate_test
    """