static {
        try {
            NTLMSSP_OID = new ASN1ObjectIdentifier("1.3.6.1.4.1.311.2.2.10");
        } catch (final IllegalArgumentException e) {
            log.error("Failed to parse OID", e);
        }
    }

    private final NtlmPasswordAuthenticator auth;
    private int ntlmsspFlags;
    private final String workstation;
    private boolean isEstablished = false;

	}

	var kids []string
	for ii, jks := range jk.Keys {
		_, err := jks.DecodePublicKey()
		if err != nil {
			t.Fatalf("Failed to decode key %d: %v", ii, err)
		}
		kids = append(kids, jks.Kid)
	}
	if len(kids) != 3 {
		t.Fatalf("Failed to find the expected number of kids: 3, got %d", len(kids))
	}
}

// A.1 - Example public keys
func TestPublicKey(t *testing.T) {
	const jsonkey = `{"keys":

			}
		case "cmp":
			z.Complete, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Complete")
				return
			}
		case "fld":
			z.Failed, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Failed")
				return
			}
		case "lbkt":
			z.Bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Bucket")
				return
			}

                logger.warn("Failed to access Web API.", e);
                message = e.getMessage();
            } else {
                final String errorCode = UUID.randomUUID().toString();
                message = "[" + errorCode + "] Failed to access to Web API.";
                logger.warn(message, e);
            }

     * @throws DcerpcException if the wrapping operation fails
     */
    void wrap(NdrBuffer outgoing) throws DcerpcException;

    /**
     * Unwraps incoming DCERPC message data after security processing
     * @param incoming the buffer containing data to be unwrapped
     * @throws DcerpcException if the unwrapping operation fails
     */
    void unwrap(NdrBuffer incoming) throws DcerpcException;

			log.Fatalln(fmt.Errorf("setting attribute %s failed with: %v", name, err))
		}
	} else {
		if name == "" {
			log.Fatalln("you must specify an attribute name for reading")
		}
		var names []string
		if name == "." {
			attrs, err := listxattr(path)
			if err != nil {
				log.Fatalln(fmt.Errorf("listing attributes failed with: %v", err))
			}
			names = append(names, attrs...)
		} else {

            throw new ExtractException("Failed to extract data.", e);
        } finally {
            if (dfos != null && !dfos.isInMemory()) {
                final File file = dfos.getFile();
                try {
                    Files.delete(file.toPath());
                } catch (final IOException e) {
                    logger.warn("Failed to delete {}.", file.getAbsolutePath(), e);
                }
            }

            bigThreadConstructor.newInstance(
                (ThreadGroup) null, finalizer, threadName, defaultStackSize, inheritThreadLocals);
      } catch (Throwable t) {
        logger.log(
            Level.INFO, "Failed to create a thread without inherited thread-local values", t);
      }
    }
    if (thread == null) {
      thread = new Thread((ThreadGroup) null, finalizer, threadName);
    }
    thread.setDaemon(true);

            assertTrue(true);
        } catch (final InterruptedException e) {
            fail("Interrupted during execution");
        } catch (final ExecutionException e) {
            fail("Execution failed: " + e.getMessage());
        } finally {
            executor.shutdown();
            try {

	// create a temp Erasure/FS backend.
	ctx, cancel := context.WithCancel(b.Context())
	defer cancel()
	objLayer, disks, err := prepareTestBackend(ctx, instanceType)
	if err != nil {
		b.Fatalf("Failed obtaining Temp Backend: <ERROR> %s", err)
	}
	// cleaning up the backend by removing all the directories and files created on function return.
	defer removeRoots(disks)