*sql.Stmt
	Transaction bool
	prepared    chan struct{}
	prepareErr  error
}

func (stmt *Stmt) Error() error {
	return stmt.prepareErr
}

func (stmt *Stmt) Close() error {
	<-stmt.prepared

	if stmt.Stmt != nil {
		return stmt.Stmt.Close()
	}
	return nil
}

// Store defines an interface for managing the caching operations of SQL statements (Stmt).

        } finally {
            if (autoStorage != null) {
                autoStorage.close();
                assertTrue(autoStorage.isDestroyed(), "Storage should be destroyed after close");
            }
        }

        // Clean up
        Arrays.fill(plaintext, '\0');
    }

    @Test
    public void testNullMasterPassword() {

        messageBuffer.readAndWriteUnsafe(maskCursor!!)
        maskCursor.seek(0L)
        toggleMask(maskCursor, maskKey)
        maskCursor.close()
      }
    }

    sinkBuffer.write(messageBuffer, dataSize)
    sink.flush()
  }

  override fun close() {
    messageDeflater?.closeQuietly()
    sink.closeQuietly()
  }

            }
            off += r;
        }
        return off;
    }

    @Override
    public void close() throws IOException {
        super.close();
        try {
            this.handle.close();
        } finally {
            this.pipe.close();
        }
    }

    if (hasErrors) {
      return
    }
    try {
      super.flush()
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun close() {
    try {
      super.close()
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

                .readAttributes();
        assertThat(attributes.permissions()).containsExactly(OWNER_READ, OWNER_WRITE);
      }
    }
    out.close();

    // Check that source returns the right data
    assertTrue(Arrays.equals(data, source.read()));

    // Make sure that reset deleted the file
    out.reset();
    if (file != null) {

 *
 * @author mbechler
 *
 */
public interface SmbRandomAccess extends DataOutput, DataInput, AutoCloseable {

    /**
     * Close the file
     *
     * @throws SmbException if an I/O error occurs during close
     */
    @Override
    void close() throws SmbException;

    /**
     * Read a single byte from the current position
     *
     * @return read byte, -1 if EOF

				t.Fatalf("unable to write previously parsed content: %s", err)
			}
		}
		if err := w.Close(); err != nil {
			t.Fatalf("Unable to write archive: %s", err)
		}

		// TODO: We may want to check if the archive roundtrips. This would require
		// taking into account addition of the two zero trailer blocks that Writer.Close
		// appends.
	})

                                                </h4>
                                                <button type="button" class="close" data-dismiss="modal"
                                                        aria-label="Close">
                                                    <span aria-hidden="true">×</span>
                                                </button>

          stale-issue-label: to-triage
          stale-issue-message: ""
          days-before-issue-close: -1

          only-pr-labels: 'from:contributor'
          exempt-all-pr-milestones: true
          days-before-pr-stale: 14
          stale-pr-label: to-triage
          stale-pr-message: ""