file('files/a.txt').text = "one + two"
        run 'copy'

        then:
        executedAndNotSkipped(':copy')
        file('dest/a.txt').text == "1 + 2"
    }

    def "useful help message when property cannot be expanded"() {
        given:
        buildFile << """
            task copy (type: Copy) {
                // two.a expects "one" to be defined
                from('src/two/two.a')

      if (type in log) {
        return log
      }
    }
    return null
  }

  private fun countFrames(
    logs: List<String>,
    message: String,
  ): Int {
    var result = 0
    for (log in logs) {
      if (log == message) {
        result++
      }
    }
    return result
  }

  /**

	unmarshal([]byte) bool
}

type handshakeMessageWithOriginalBytes interface {
	handshakeMessage

	// originalBytes should return the original bytes that were passed to
	// unmarshal to create the message. If the message was not produced by
	// unmarshal, it should return nil.
	originalBytes() []byte
}

// lruSessionCache is a ClientSessionCache implementation that uses an LRU
// caching strategy.

        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isIn("timeout", "Read timed out")
    }
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart", "ProxySelectEnd", "DnsStart", "DnsEnd",

	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AggregationRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AggregationRule.Merge(m, src)
}
func (m *AggregationRule) XXX_Size() int {
	return m.Size()
}
func (m *AggregationRule) XXX_DiscardUnknown() {
	xxx_messageInfo_AggregationRule.DiscardUnknown(m)

	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AggregationRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AggregationRule.Merge(m, src)
}
func (m *AggregationRule) XXX_Size() int {
	return m.Size()
}
func (m *AggregationRule) XXX_DiscardUnknown() {
	xxx_messageInfo_AggregationRule.DiscardUnknown(m)

	88:  "malformed Mach-o file",
	89:  "operation canceled",
	90:  "identifier removed",
	91:  "no message of desired type",
	92:  "illegal byte sequence",
	93:  "attribute not found",
	94:  "bad message",
	95:  "EMULTIHOP (Reserved)",
	96:  "no message available on STREAM",
	97:  "ENOLINK (Reserved)",
	98:  "no STREAM resources",
	99:  "not a STREAM",
	100: "protocol error",

	{117, "ECANCELED", "asynchronous I/O cancelled"},
	{118, "ENOSR", "out of STREAMS resources"},
	{119, "ETIME", "system call timed out"},
	{120, "EBADMSG", "next message has wrong type"},
	{121, "EPROTO", "error in protocol"},
	{122, "ENODATA", "no message on stream head read q"},
	{123, "ENOSTR", "fd not associated with a stream"},
	{124, "ENOTSUP", "unsupported attribute value"},
	{125, "EMULTIHOP", "multihop is not allowed"},

	"message":            "message is a human readable message indicating details about the transition. This may be an empty string.",
}

func (Condition) SwaggerDoc() map[string]string {
	return map_Condition
}

// it will be stopped and joined.
TF_CAPI_EXPORT extern void TF_DeleteServer(TF_Server* server);

// Register a listener method that processes printed messages.
//
// If any listeners are registered, the print operator will call all listeners
// with the printed messages and immediately return without writing to the
// logs.
TF_CAPI_EXPORT extern void TF_RegisterLogListener(
    void (*listener)(const char*));