lockedConf 'org:bar:1.+'
}
"""

        when:
        succeeds'dependencies', '--write-locks', '--refresh-dependencies'

        then:
        lockfileFixture.verifyLockfile('lockedConf', ['org:foo:1.0', 'org:bar:1.0'])
    }

	// number of goroutines holding a conceptual write lock
	// on ForkLock.
	forking int
)

// hasWaitingReaders reports whether any goroutine is waiting
// to acquire a read lock on rw. It is defined in the sync package.
func hasWaitingReaders(rw *sync.RWMutex) bool

// acquireForkLock acquires a write lock on ForkLock.
// ForkLock is exported and we've promised that during a fork

	v1 t1
	v2 t2

	v1s []t1
	v2s []t2
)

func f() {
	// Test direct writes
	v1.x = nil        // no barrier
	v2.x = nil        // ERROR "write barrier"
	v1.s = []nih(nil) // no barrier
	v2.s = []ih(nil)  // ERROR "write barrier"
}

func g() {
	// Test aggregate writes
	v1 = t1{x: nil} // no barrier
	v2 = t2{x: nil} // ERROR "write barrier"
}

func h() {
	// Test copies and appends.

  }

  /**
   * Writes an {@code int} as specified by {@link DataOutputStream#writeInt(int)}, except using
   * little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeInt(int v) throws IOException {
    out.write(0xFF & v);
    out.write(0xFF & (v >> 8));
    out.write(0xFF & (v >> 16));
    out.write(0xFF & (v >> 24));
  }

  /**

    StringBuilder builder = new StringBuilder();
    Writer writer = new AppendableWriter(builder);

    writer.write("Hello".toCharArray());
    writer.write(',');
    writer.write(0xBEEF0020); // only lower 16 bits are important
    writer.write("Wo");
    writer.write("Whirled".toCharArray(), 3, 2);
    writer.write("Mad! Mad, I say", 2, 2);

    assertEquals("Hello, World!", builder.toString());
  }

    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

  @Override
  public void write(String str, int off, int len) throws IOException {

        Objects.requireNonNull(output, "output cannot be null");
        Objects.requireNonNull(settings, "settings cannot be null");

        try (Writer out = output) {
            new SettingsStaxWriter().write(out, settings.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException("Error writing settings", e);
        }

        def outputStream = new ByteArrayOutputStream()
        def encoder = new EncodedStream.EncodedOutput(outputStream)

        when:
        encoder.write(0)
        encoder.write(127)
        encoder.write(128)
        encoder.write(255)
        encoder.flush()

        then:
        def inputStream = new ByteArrayInputStream(outputStream.toByteArray())

    if (JAVA_IO_TMPDIR.value().equals("/sdcard")) {
      assertThrows(IOException.class, () -> out.write(data));
      return;
    }
    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.close();
    assertThrows(IOException.class, () -> out.write(42));

    // Verify that write had no effect
    assertTrue(Arrays.equals(data, source.read()));
    out.reset();
  }

    }

    @Override
    public synchronized void write(int b) throws IOException {
        delegate.write(b);
    }

    @Override
    public synchronized void write(byte[] b) throws IOException {
        delegate.write(b);
    }

    @Override
    public synchronized void write(byte[] b, int off, int len) throws IOException {
        delegate.write(b, off, len);
    }

    @Override