true), RESOURCE_LOCKED("Resource is locked", ErrorCategory.RESOURCE, true),

        // Transient errors
        BUSY("Server busy", ErrorCategory.TRANSIENT, true), TRY_AGAIN("Try again later", ErrorCategory.TRANSIENT,
                true), SERVICE_UNAVAILABLE("Service temporarily unavailable", ErrorCategory.TRANSIENT, true),

        // Generic errors

        return severity == Severity.RECOVERABLE || severity == Severity.TRANSIENT;
    }

    /**
     * Checks if retry should be attempted
     *
     * @return true if retry is recommended
     */
    public boolean shouldRetry() {
        return severity == Severity.RECOVERABLE || severity == Severity.TRANSIENT;
    }

    /**
     * Gets recommended retry delay in milliseconds
     *

 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class CartesianList<E> extends AbstractList<List<E>> implements RandomAccess {

  private final transient ImmutableList<List<E>> axes;
  private final transient int[] axesSizeProduct;

  static <E> List<List<E>> create(List<? extends List<? extends E>> lists) {
    ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size());

	Create bool

	// Include pure directories.
	IncludeDirectories bool

	// Transient is set if the cache is transient due to an error or being a reserved bucket.
	// This means the cache metadata will not be persisted on disk.
	// A transient result will never be returned from the cache so knowing the list id is required.
	Transient bool

	// Versioned is this a ListObjectVersions call.
	Versioned bool
	// V1 listing type

     * @param resourceType the type of resource
     */
    public SmbResourceException(String message, int errorCode, ResourceType resourceType) {
        super(message, errorCode, Severity.TRANSIENT, Category.RESOURCE);
        this.resourceType = resourceType;
        this.availableResources = -1;
        this.requestedResources = -1;
    }

    /**
     * Creates a resource exception with resource details

    /**
     * Flag indicating whether this handle is currently being reconnected
     */
    private volatile boolean reconnecting;

    // Not serialized - will be null after deserialization
    private transient Object file; // Reference to SmbFile (avoid circular dependencies)

    /**
     * Create new handle information
     * @param path the file path
     * @param guid the create GUID

    /** The rule ID. */
    protected String ruleId;

    /** The response processor. */
    protected ResponseProcessor responseProcessor;

    /** The crawler container. */
    @Resource
    protected transient CrawlerContainer crawlerContainer;

    /**
     * Constructs a new AbstractRule.
     */
    public AbstractRule() {
        // NOP
    }

    /**
     * Registers this rule with the {@link RuleManager}.

        assertFalse(exception.isNetworkError());
        assertFalse(exception.isAuthenticationError());
        assertTrue(exception.isFileSystemError());
        assertFalse(exception.isTransientError());

        // Transient error
        exception = new SmbOperationException(SmbOperationException.ErrorCode.SERVICE_UNAVAILABLE, "Server busy");
        assertFalse(exception.isNetworkError());
        assertFalse(exception.isAuthenticationError());

        ois.close();

        // Verify
        assertEquals("serializeRule", deserializedRule.getRuleId());
        assertNotNull(deserializedRule.getResponseProcessor());

        // Note: crawlerContainer is transient (marked with @Resource)
        // so it won't be serialized
        assertNull(deserializedRule.crawlerContainer);
    }

    /**
     * Test with null CrawlerContainer
     */

test --test_env="GTEST_INSTALL_FAILURE_SIGNAL_HANDLER=1"


# Default options should come above this line.

# Android configs. Bazel needs to have --cpu and --fat_apk_cpu both set to the
# target CPU to build transient dependencies correctly. See
# https://docs.bazel.build/versions/master/user-manual.html#flag--fat_apk_cpu
build:android --config=clang_local
build:android --crosstool_top=//external:android/crosstool