// The name variable only exists for testing. It is otherwise always
// "/etc/resolv.conf".
func (conf *resolverConfig) tryUpdate(name string) {
	conf.initOnce.Do(conf.init)

	if conf.dnsConfig.Load().noReload {
		return
	}

	// Ensure only one update at a time checks resolv.conf.
	if !conf.tryAcquireSema() {
		return
	}
	defer conf.releaseSema()

	now := time.Now()

            println 'Resource action executed'
        }
    }
}

dependencies {
    components {
        all(AssertingRule)
    }
    conf 'org:my-lib:1.0'
}

task resolve {
    def files = configurations.conf
    doLast {
        files.forEach { }
    }
}
"""
        when:
        succeeds 'resolve'

        then:
        outputContains('AssertingRule executed')

	if err := conn.SetWriteDeadline(deadline); err != nil {
		return outBuffer.String(), err
	}
	if err := conn.SetReadDeadline(deadline); err != nil {
		return outBuffer.String(), err
	}

	start := time.Now()
	err = conn.WriteMessage(websocket.TextMessage, []byte(req.Message))
	if err != nil {
		return outBuffer.String(), err
	}

	_, resp, err := conn.ReadMessage()
	if err != nil {

// newSymlinkedWatchFile simulates the behavior of k8s configmap/secret.
// Path structure looks like:
//
//	<watchDir>/test.conf
//	             ^
//	             |
//
// <watchDir>/data/test.conf
//
//	^
//	|
//
// <watchDir>/data1/test.conf
func newSymlinkedWatchFile(t *testing.T) (string, string) {
	g := NewGomegaWithT(t)

	watchDir := t.TempDir()

	dataDir1 := path.Join(watchDir, "data1")

		fwLog.Infof("TCP forwarder using PROXY protocol version %d", cfg.proxyProtocolVersion)
		header := proxyproto.HeaderProxyFromAddrs(byte(cfg.proxyProtocolVersion), conn.LocalAddr(), conn.RemoteAddr())
		// After the connection is created, write the proxy headers first
		if _, err := header.WriteTo(conn); err != nil {
			fwLog.Warnf("TCP Proxy protocol header write failed: %v", err)
			return msgBuilder.String(), err
		}
	}

	"arm64": obj.Linknew(&arm64.Linkarm64),
}

func testConfig(tb testing.TB) *Conf      { return testConfigArch(tb, "amd64") }
func testConfigS390X(tb testing.TB) *Conf { return testConfigArch(tb, "s390x") }
func testConfigARM64(tb testing.TB) *Conf { return testConfigArch(tb, "arm64") }

func testConfigArch(tb testing.TB, arch string) *Conf {
	ctxt, ok := testCtxts[arch]
	if !ok {
		tb.Fatalf("unknown arch %s", arch)
	}

            repositories { maven { url "${mavenRepo.uri}" } }

            configurations {
                conf
            }

            task resolve {
                dependsOn configurations.conf
                doLast {
                    def expectedResult = result.split(",")
                    assert configurations.conf.files.collect { it.name } == expectedResult
                }
            }
        """
    }

		log.Fatalf("Failed to resolve TCP addr %v %v", host, port)
	}

	conn, err := net.DialTCP("tcp", nil, addr)
	if err != nil {
		log.Fatalf("Failed to connect to %s:%s because %s", host, port, err)
	}
	defer conn.Close()

	var wg sync.WaitGroup
	wg.Add(2)

	go func() {
		defer func() {
			os.Stdout.Close()
			os.Stdin.Close()
			conn.CloseRead()
			wg.Done()
		}()

		_, err := io.Copy(os.Stdout, conn)

                configurations { conf }
                dependencies {
                    ${platformDependency(platformType, 'org:platform:1.+')}
                    conf('org:bar')
                }
            }
            dependencies {
                conf(project(path: ':recklessLibrary', configuration: 'conf'))
                conf(project(path: ':secondLibrary', configuration: 'conf'))
            }

	// cond: v.Block == z.Block
	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
	for {
		if auxIntToInt64(v.AuxInt) != 0 {
			break
		}
		z := v_0
		if z.Op != OpPPC64CNTLZD {
			break
		}
		if !(v.Block == z.Block) {
			break
		}
		v.reset(OpPPC64CMPconst)
		v.AuxInt = int64ToAuxInt(0)
		v.AddArg(convertPPC64OpToOpCC(z))
		return true
	}
	// match: (CMPconst [0] z:(RLDICL x))