// errorcheck

// Copyright 2019 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.

// Check error message for duplicated index in slice literal

package p

var s = []string{
	1: "dup",
	1: "dup", // ERROR "duplicate index in slice literal: 1|duplicate value for index 1|duplicate index 1"

// RUN: not tf-tfrt-opt -tfrt-deduplicate-functions-invoked-by-batch-function %s 2>&1 | FileCheck %s

// This test verifies the error when two functions are different but invoked by
// the batch functions with same shared_name.

func.func private @batch_0(%arg0: tensor<?x?xi32>) -> tensor<*xi32> {

// errorcheck

// Copyright 2014 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.

// Issue 7153: array invalid index error duplicated on successive bad values

package p

// RUN: tf-tfrt-opt -split-input-file -tfrt-deduplicate-if-result %s | FileCheck %s -dump-input=fail

func.func private @then(%x: tensor<i32>, %y: tensor<i32>) -> (tensor<i32>, tensor<i32>) {
  func.return %x, %x : tensor<i32>, tensor<i32>
}

func.func private @else(%x: tensor<i32>, %y: tensor<i32>) -> (tensor<i32>, tensor<i32>) {
  func.return %y, %y : tensor<i32>, tensor<i32>
}

// CHECK-LABEL: then/tfrt_dedup_results

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// When the function Store an Arg and also use it in another place,
// be sure not to generate duplicated OpArgXXXReg values, which confuses
// the register allocator.

package main

//go:noinline
//go:registerparams
func F(x, y float32) {
	if x < 0 {
		panic("FAIL")
	}
	g = [4]float32{x, y, x, y}
}

	// as it only contains frame pointer operations,
	// which are very similar across functions.
	// These are referenced by .pdata entries using
	// an RVA, so it is possible, and binary-size wise,
	// to deduplicate .xdata entries.
	uwcache := make(map[string]int64) // aux symbol name --> .xdata offset
	for _, s := range ctxt.Textp {
		if fi := ldr.FuncInfo(s); !fi.Valid() {
			continue
		}
		uw := ldr.SEHUnwindSym(s)

		if err != nil {
			log.Fatal(err)
		}
		defer f.Close()
		_, err = io.WriteString(f, file.contents)
		if err != nil {
			log.Fatal(err)
		}
	}
	return dir
}

// The following example is duplicated in text/template; keep them in sync.

// Here we demonstrate loading a set of templates from a directory.
func ExampleTemplate_glob() {
	// Here we create a temporary directory and populate it with our sample

        for (int i = 0; i < 3; i++) {
            emitter.emit(createMockProblem("foo$i"))
        }

        then:
        3 * eventConsumer.progress(_)
    }

    def "emit summary if there are deduplicate events"() {
        given:
        def eventConsumer = Mock(ProgressEventConsumer)
        def emitter = new AggregatingProblemConsumer(eventConsumer, { new OperationIdentifier(1) })

        when:

			},
			query: map[string]interface{}{
				"k":  "a",
				"v1": "A",
			},
			expected: map[string]interface{}{
				"k":  "a",
				"v1": "a",
			},
		},
		{
			name: "keep first entry when duplicated keys are encountered",
			sts: &spec.Schema{
				SchemaProps: spec.SchemaProps{
					Type: []string{"array"},
				},
				VendorExtensible: spec.VendorExtensible{Extensions: map[string]interface{}{

			},
			query: map[string]interface{}{
				"k":  "a",
				"v1": "A",
			},
			expected: map[string]interface{}{
				"k":  "a",
				"v1": "a",
			},
		},
		{
			name: "keep first entry when duplicated keys are encountered",
			sts: schema.Structural{
				Generic: schema.Generic{
					Type: "array",
				},
				Extensions: schema.Extensions{
					XListType:    &listTypeMap,
					XListMapKeys: []string{"k"},