String wagon, final Exception exception, final int requestType, ArtifactTransferResource artifact) {
        this(wagon, TRANSFER_ERROR, requestType, artifact);

        this.exception = exception;
    }

    public ArtifactTransferResource getResource() {
        return artifact;
    }

    /**
     * @return Returns the exception.
     */
    public Exception getException() {

                assertNotNull(result);
            } catch (Exception e) {
                // Expected behavior when components are not fully initialized
                Throwable cause = e.getCause();
                assertNotNull(cause);
            }
        } catch (Exception e) {
            // Test setup exception is acceptable
            assertNotNull(e);
        }

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.exception;

/**
 * Exception thrown when an argument is empty.
 *
 * @author higa
 */
public class EmptyArgumentException extends ClIllegalArgumentException {

    private static final long serialVersionUID = 4625805280526951642L;

 *
 */
public class LongConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToLong() throws Exception {
        assertEquals(Long.valueOf("1000"), LongConversionUtil.toLong("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveLong() throws Exception {
        assertEquals(1000, LongConversionUtil.toPrimitiveLong("1,000"));
    }

    /**

        QueryContext context = new QueryContext("test", false);

        try {
            boostQueryCommand.execute(context, null, 1.0f);
            fail("Should have thrown exception");
        } catch (Exception e) {
            // Expected exception (either InvalidQueryException or NullPointerException)
            assertTrue(e instanceof InvalidQueryException || e instanceof NullPointerException);
        }
    }

                } else {
                    String errorMsg = response != null ? response.getError() : "Response was null";
                    throw new IOException("Witness registration failed: " + errorMsg);
                }

            } catch (Exception e) {
                log.error("Failed to register for witness notifications", e);
                throw new RuntimeException(e);
            }
        });
    }

    private int count;

    private String names = "";

    /**
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        DisposableUtil.dispose();
    }

    /**
     * @throws Exception
     */
    @Test
    public void test1() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));
        assertThat(DisposableUtil.disposables.size(), is(1));

import org.codelibs.fess.crawler.entity.AccessResultDataImpl;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.entity.ResultData;
import org.codelibs.fess.crawler.exception.CrawlerSystemException;
import org.codelibs.fess.crawler.extractor.ExtractorFactory;
import org.codelibs.fess.crawler.extractor.impl.TikaExtractor;
import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke

            } catch (Exception e) {
                // Expected due to missing dependencies in test environment
                assertTrue(true);
                return;
            }
            // Should handle null keywords gracefully
            assertNotNull(functionBuilders);
        } catch (Exception e) {
            // May throw exception due to null handling
            assertNotNull(e);

  @Override
  protected void tearDown() {
    stack.runTearDown();
  }

  static final Exception EXCEPTION = new Exception();

  static final class ExampleClassUnderTest {
    static final Logger logger = Logger.getLogger(ExampleClassUnderTest.class.getName());

    static void foo() {
      logger.log(Level.INFO, "message", EXCEPTION);
    }

    private ExampleClassUnderTest() {}
  }