import org.gradle.internal.time.Time
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import spock.lang.Specification

class Slf4jLoggingConfigurerTest extends Specification {
    Logger logger = LoggerFactory.getLogger("cat1")
    OutputEventListener listener = Mock()
    Slf4jLoggingConfigurer configurer = new Slf4jLoggingConfigurer(listener)

    def cleanup() {

                }
                variant('runtime1') {
                    attribute('custom2', 'c1')
                    capability('cap2')
                }
                variant('runtime2') {
                    attribute('custom2', 'c2')
                    capability('cap2')
                }
            }
        }

        buildFile << """
            dependencies {
                conf('org:test:1.0') {

Than McIntosh <******@****.***> 1647953392 -0400

// This pattern optimizes:
//   (x + cst1) + cst2 -> x + cst
//   (x - cst1) - cst2 -> x - cst
// Where: cst = cst1 + cst2
foreach BinaryOp = [TF_AddV2Op, TF_SubOp] in {
  def OptimizeConsecutive#BinaryOp : Pat<
    (BinaryOp
      (BinaryOp $x, (TF_ConstOp:$cst1 $cst1_value)),
      (TF_ConstOp:$cst2 $cst2_value)),
    (BinaryOp
      $x, (TF_AddV2Op $cst1, $cst2))>;
}

// This pattern optimizes:

                $compare_type2),
              (MHLO_CompareOp:$rnz $rem1, (MHLO_ConstantOp $cst2), MHLO_ComparisonDirectionValue<"NE">, $compare_type3)),
            (MHLO_AddOp $rem2, $arg1),
            $rem3),
          (TF_FloorModOp $arg, $arg1),
          [(ValueEquals<"0.0"> $cst),
           (ValueEquals<"0.0"> $cst1),
           (ValueEquals<"0.0"> $cst2),
           (SameValue $rem, $rem1),
           (SameValue $rem, $rem2),

			if !bytes.Equal(cdat1, cdat2) {
				t.Errorf("bytesPerPixel: %d\npdat0: % x\ncdat0: % x\ngot:   % x\nwant:  % x", bytesPerPixel, pdat0, cdat0, cdat1, cdat2)
				break
			}
		}
	}

//go:noinline
func ip64(v int64) *int64 {
	return &v
}

func TestFloatConvert(t *testing.T) {
	if got := cvt1(3.5); got != 3 {
		t.Errorf("cvt1 got %d, wanted 3", got)
	}
	if got := cvt2(3.5); got != 3 {
		t.Errorf("cvt2 got %d, wanted 3", got)
	}
	if got := cvt3(3.5); got != 3 {
		t.Errorf("cvt3 got %d, wanted 3", got)
	}
	if got := cvt4(3.5); got != 3 {
		t.Errorf("cvt4 got %d, wanted 3", got)
	}

func ExampleValues_Add() {
	v := url.Values{}
	v.Add("cat sounds", "meow")
	v.Add("cat sounds", "mew")
	v.Add("cat sounds", "mau")
	fmt.Println(v["cat sounds"])

	// Output:
	// [meow mew mau]
}

func ExampleValues_Del() {
	v := url.Values{}
	v.Add("cat sounds", "meow")
	v.Add("cat sounds", "mew")
	v.Add("cat sounds", "mau")
	fmt.Println(v["cat sounds"])

	v.Del("cat sounds")
	fmt.Println(v["cat sounds"])

        // CHECK: tf_device.cluster
        // CHECK-DAG: %[[CST2:.*]] = "tf.Const"{{.*}}2.0
        // CHECK-DAG: %[[CST3:.*]] = "tf.Const"{{.*}}3.0
        // CHECK-DAG: %[[CST4:.*]] = "tf.Const"{{.*}}4.0
        // CHECK-NOT:"tf.Const"
        // CHECK: %[[MUL1:.*]] = "tf.Mul"(%arg0, %[[CST2]])
        // CHECK-NEXT: %[[MUL2:.*]] = "tf.Mul"(%[[MUL1]], %[[CST2]])
        // CHECK-NEXT: %[[MUL3:.*]] = "tf.Mul"(%[[MUL2]], %[[CST3]])

        def fat1 = Mock(FileAccessTracker)
        def fat2 = Mock(FileAccessTracker)

        when:
        twoStageStore.getFileAccessTracker().markAccessed(file)

        then:
        1 * readStore.getFileAccessTracker() >> fat1
        1 * writeStore.getFileAccessTracker() >> fat2
        1 * fat1.markAccessed(file)
        1 * fat2.markAccessed(file)
    }