switch fd.net {
	case "tcp":
		return &TCPListener{fd: fd}
	default:
		panic("unsupported network for file listener: " + fd.net)
	}
}

func newFileConn(fd *netFD) Conn {
	switch fd.net {
	case "tcp":
		return &TCPConn{conn{fd: fd}}
	case "udp":
		return &UDPConn{conn{fd: fd}}
	default:
		panic("unsupported network for file connection: " + fd.net)
	}
}

			expectedError: true,
		},
		{
			name:          "invalid: too many arguments",
			args:          []string{"", ""},
			expectedError: true,
		},
		{
			name:          "invalid: unsupported shell name",
			args:          []string{"unsupported"},
			expectedError: true,
		},
	}

	// test all supported shells
	shells := GetSupportedShells()
	if len(shells) == 0 {
		t.Errorf(shellsError)
	}

    } catch (NullPointerException expected) {
    }
    expectUnchanged();
    expectNullKeyMissingWhenNullKeysUnsupported(
        "Should not contain null key after unsupported putIfAbsent(null, value)");
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  public void testPutIfAbsent_nullValueUnsupported() {
    try {
      getMap().putIfAbsent(k3(), null);

      fail("putIfAbsent(null, value) should throw");
    } catch (NullPointerException expected) {
    }
    expectUnchanged();
    expectNullKeyMissingWhenNullKeysUnsupported(
        "Should not contain null key after unsupported putIfAbsent(null, value)");
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  public void testPutIfAbsent_nullValueUnsupportedAndKeyAbsent() {
    try {

        failure.assertHasCause(cause)

        where:
        writeCharset    | readCharset     | cause
        "'UNSUPPORTED'" | "'UTF-8'"       | "Charset for manifestContentCharset 'UNSUPPORTED' is not supported by your JVM"
        "'UTF-8'"       | "'UNSUPPORTED'" | "Charset for contentCharset 'UNSUPPORTED' is not supported by your JVM"
        null            | "'UTF-8'"       | "manifestContentCharset must not be null"

	{DefaultParameterConverter, bs{1}, []byte{1}, ""},
	{DefaultParameterConverter, s("a"), "a", ""},
	{DefaultParameterConverter, t(now), nil, "unsupported type driver.t, a struct"},
	{DefaultParameterConverter, is{1}, nil, "unsupported type driver.is, a slice of int"},
	{DefaultParameterConverter, dec{exponent: -6}, dec{exponent: -6}, ""},
}

func TestValueConverters(t *testing.T) {

 * Object#hashCode} and {@link Object#toString}. For example:
 *
 * <pre>
 * class Unsupported extends AbstractInvocationHandler {
 *   protected Object handleInvocation(Object proxy, Method method, Object[] args) {
 *     throw new UnsupportedOperationException();
 *   }
 * }
 *
 * CharSequence unsupported = Reflection.newProxy(CharSequence.class, new Unsupported());
 * </pre>
 *
 * @author Ben Yu
 * @since 12.0
 */

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |

            withProblem("Build file 'build.gradle': line 11: invocation of 'Task.project' at execution time is unsupported.")
            withProblem("Build file 'build.gradle': line 4: execution of task ':offender' caused invocation of 'Task.project' in other task at execution time which is unsupported.")
        }
    }

    @Issue('https://github.com/gradle/gradle/issues/22522')

	alertDecompressionFailure:         "decompression failure",
	alertHandshakeFailure:             "handshake failure",
	alertBadCertificate:               "bad certificate",
	alertUnsupportedCertificate:       "unsupported certificate",
	alertCertificateRevoked:           "revoked certificate",
	alertCertificateExpired:           "expired certificate",
	alertCertificateUnknown:           "unknown certificate",