}

            String goalName = context.options().goals().get().get(0);
            Goal goal = context.goals.get(goalName);
            if (goal == null) {
                return badGoalsErrorMessage("Unknown goal: " + goalName, context);
            }

            return goal.execute(context);
        } catch (InterruptedException | InterruptedIOException | UserInterruptException e) {

        });

        assertEquals("Missing AvEOL", exception.getMessage(), "Should throw exception for truncated data");
    }

    /**
     * Test decode with unknown AvPair type
     */
    @Test
    @DisplayName("Decode unknown AvPair type as generic AvPair")
    void testDecodeUnknownType() throws CIFSException {
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        int unknownType = 0xFF;

                } catch (final CIFSException e) {
                    if (!(e.getCause() instanceof UnknownHostException)) {
                        throw e;
                    }
                    log.debug("Unknown host", e);
                }
                this.type = SmbConstants.TYPE_SERVER;
            }
        }
        return this.type;
    }

    /**
     * {@inheritDoc}
     *

          System.out.println("completed");
        } else {
          if (firstUpdate) {
            firstUpdate = false;
            if (contentLength == -1) {
              System.out.println("content-length: unknown");
            } else {
              System.out.format("content-length: %d\n", contentLength);
            }
          }

          System.out.println(bytesWritten);

          if (contentLength != -1) {

                message += "\n  " + methodLinkMetaData;
            }
            message += "\nThis problem may happen when some apilink from docbook template xmls refers to unknown method."
                    + "\nExample: <apilink class=\"org.gradle.api.Project\" method=\"someMethodThatDoesNotExist\"/>";
            throw new RuntimeException(message);
        }
        if (candidates.size() != 1) {

	if err != nil {
		return err
	}
	if dest.StorageClass != "" {
		switch dest.StorageClass {
		case "STANDARD", "REDUCED_REDUNDANCY":
		default:
			return fmt.Errorf("unknown storage class %s", dest.StorageClass)
		}
	}
	parsedDest.StorageClass = dest.StorageClass
	*d = parsedDest
	return nil
}

// Validate - validates Resource is for given bucket or not.

        is KotlinClassMetadata.MultiFileClassFacade -> false
        is KotlinClassMetadata.SyntheticClass -> false
        is KotlinClassMetadata.Unknown -> false
    }


private
fun hasClassAttribute(kmClassSupplier: Supplier<KmClass>, memberType: MemberType, jvmSignature: String, predicate: AttributePredicate): Boolean {
    val kmClass = kmClassSupplier.get()

                break;
            case WAIT_NEW_URL:
                delayForWaitingNewUrl();
                break;
            default:
                if (logger.isDebugEnabled()) {
                    logger.debug("Unknown delay type: {}", type);
                }
                break;
            }
        } catch (final CrawlerSystemException e) {
            if (!ignoreException) {
                throw e;
            }

			if err != nil {
				return nil, fmt.Errorf("readXLMetaNoData(read_meta): unknown metadata version %w", err)
			}
			want += int64(len(tmp) - len(after))

			return buf[:want], err

		default:
			return nil, errors.New("unknown minor metadata version")
		}
	default:
		return nil, errors.New("unknown major metadata version")
	}
}

	case simdjson.TypeNull:
		return sql.FromNull(), nil
	case simdjson.TypeObject, simdjson.TypeArray:
		b, err := iter.MarshalJSON()
		return sql.FromBytes(b), err
	}
	return nil, fmt.Errorf("iterToValue: unknown JSON type: %s", iter.Type().String())
}

// Reset the record.
func (r *Record) Reset() {
	r.object = simdjson.Object{}
}

// Clone the record and if possible use the destination provided.