}

	DB.Model(&person).Association("Addresses").Clear()

	if DB.Model(&person).Association("Addresses").Count() != 0 {
		t.Fatalf("Should deleted all addresses")
	}

	if DB.Unscoped().Model(&person).Association("Addresses").Count() != 2 {
		t.Fatalf("Should found soft deleted addresses with unscoped")
	}

	DB.Unscoped().Model(&person).Association("Addresses").Clear()

    }

    /**
     * Starts reading from the given offset.
     */
    public DataInputStream start(long offset) throws IOException {
        file.seek(offset);
        bufferedInputStream.clear();
        countingInputStream = new CountingInputStream(bufferedInputStream);
        return new DataInputStream(countingInputStream);
    }

    /**

            }
            return v
        }

        @Override
        void put(K key, V value) {
            values.put(key, value)
        }

        @Override
        void clear() {
            values.clear()
        }
    }

        "TaskContainer.remove(Object)"             | "tasks.remove(foo)"
        "TaskContainer.removeAll(Collection)"      | "tasks.removeAll([foo])"
        "TaskContainer.clear()"                    | "tasks.clear()"
        "TaskContainer.retainAll(Collection)"      | "tasks.retainAll([foo])"
        "TaskContainer.iterator()#remove()"        | "def it = tasks.iterator(); it.next(); it.remove()"
    }

import org.gradle.plugin.management.internal.PluginRequests;

/**
 * <p>
 * Certain plugins are important enough that Gradle should auto-apply them when it is clear
 * that the user is trying to use it. For instance, when the user uses the <code>--scan</code> option, it
 * is clear they expect the build scan plugin to be applied.
 * </p>
 *

  }

  /**
   * A sensible definition of {@link #clear} in terms of {@link #iterator}, using the iterator's
   * {@code remove} method. If you override {@link #iterator}, you may wish to override {@link
   * #clear} to forward to this implementation.
   *
   * @since 7.0
   */
  protected void standardClear() {
    Iterators.clear(iterator());
  }

  /**

  }

  /**
   * A sensible definition of {@link #clear} in terms of {@link #iterator}, using the iterator's
   * {@code remove} method. If you override {@link #iterator}, you may wish to override {@link
   * #clear} to forward to this implementation.
   *
   * @since 7.0
   */
  protected void standardClear() {
    Iterators.clear(iterator());
  }

  /**

        destroyableHierarchy = new ExecutionNodeAccessHierarchy(caseSensitivity, stat);
    }

    @Override
    public void discardAll() {
        outputHierarchy.clear();
        destroyableHierarchy.clear();
    }

    /**
     * Create the input node access hierarchy.
     *
     * For performance reasons, we keep one input node access hierarchy per project,

                return currentReadChunk.readBuffer();
            }
            return null;
        }
    }

    public void clear() {
        chunks.clear();
        currentReadChunk = null;
        totalBytesUnreadInList = 0;
        currentWriteChunk.clear();
    }

    def "can re-add an ordinary value after clear"() {
        when:
        source.add("a")
        source.add("b")
        source.clear()

        then:
        source.iterator().collect() == []

        when:
        source.add("a")
        source.add("b")

        then:
        source.iterator().collect() == ["a", "b"]

        when:
        source.clear()
        source.add("b")