~xnox/upstart/upstart-async-run-dead-code : revision 1618.2.5

1

/*

2

* FIXME: test_job_process has been left behind

3

*/

1

4

/* upstart

2

5

*

3

6

* test_job_process.c - test suite for init/job_process.c

147

150

static int get_available_pty_count (void) __attribute__((unused));

148

151

static void close_all_files (void);

149

152

150

/**

151

* fd_valid:

152

* @fd: file descriptor.

153

*

154

* Return 1 if @fd is valid, else 0.

155

**/

156

static int

157

fd_valid (int fd)

158

{

159

int flags = 0;

160

161

if (fd < 0)

162

return 0;

163

164

errno = 0;

165

flags = fcntl (fd, F_GETFL);

166

167

if (flags < 0)

168

return 0;

169

170

/* redundant really */

171

if (errno == EBADF)

172

return 0;

173

174

return 1;

175

}

176

177

153

static void

178

154

child (enum child_tests test,

179

155

const char *filename)

409

385

* (Such tests are handled in the bundled test_user_sessions.sh script).

410

386

*/

411

387

void

412

test_run (void)

388

test_start (void)

413

389

{

414

390

char dirname[PATH_MAX];

415

391

JobClass *class = NULL;

418

394

struct stat statbuf;

419

395

char filename[PATH_MAX], buf[80];

420

396

char function[PATH_MAX];

421

int ret = -1, status, first;

397

int status;

422

398

siginfo_t info;

423

399

char filebuf[1024];

424

400

struct passwd *pwd;

433

409

log_unflushed_init ();

434

410

job_class_init ();

435

411

436

TEST_FUNCTION ("job_process_run");

412

TEST_FUNCTION ("job_process_start");

437

413

438

414

TEST_FILENAME (filename);

439

415

program_name = "test";

467

443

job->state = JOB_SPAWNED;

468

444

}

469

445

470

ret = job_process_run (job, PROCESS_MAIN);

471

TEST_EQ (ret, 0);

446

job_process_start (job, PROCESS_MAIN);

472

447

473

448

TEST_NE (job->pid[PROCESS_MAIN], 0);

474

449

502

477

job->state = JOB_SPAWNED;

503

478

}

504

479

505

ret = job_process_run (job, PROCESS_MAIN);

506

TEST_EQ (ret, 0);

480

job_process_start (job, PROCESS_MAIN);

507

481

508

482

TEST_NE (job->pid[PROCESS_MAIN], 0);

509

483

544

518

job->state = JOB_SPAWNED;

545

519

}

546

520

547

ret = job_process_run (job, PROCESS_MAIN);

548

TEST_EQ (ret, 0);

521

job_process_start (job, PROCESS_MAIN);

549

522

550

523

TEST_NE (job->pid[PROCESS_MAIN], 0);

551

524

584

557

job->state = JOB_SPAWNED;

585

558

}

586

559

587

ret = job_process_run (job, PROCESS_MAIN);

588

TEST_EQ (ret, 0);

560

job_process_start (job, PROCESS_MAIN);

589

561

590

562

TEST_NE (job->pid[PROCESS_MAIN], 0);

591

563

625

597

job->state = JOB_SPAWNED;

626

598

}

627

599

628

ret = job_process_run (job, PROCESS_MAIN);

629

TEST_EQ (ret, 0);

600

job_process_start (job, PROCESS_MAIN);

630

601

631

602

TEST_NE (job->pid[PROCESS_MAIN], 0);

632

603

672

643

"CRACKLE=FIZZ"));

673

644

}

674

645

675

ret = job_process_run (job, PROCESS_MAIN);

676

TEST_EQ (ret, 0);

646

job_process_start (job, PROCESS_MAIN);

677

647

678

648

TEST_NE (job->pid[PROCESS_MAIN], 0);

679

649

728

698

"CRACKLE=FIZZ"));

729

699

}

730

700

731

ret = job_process_run (job, PROCESS_MAIN);

732

TEST_EQ (ret, 0);

701

job_process_start (job, PROCESS_MAIN);

733

702

734

703

TEST_NE (job->pid[PROCESS_MAIN], 0);

735

704

785

754

"CRACKLE=FIZZ"));

786

755

}

787

756

788

ret = job_process_run (job, PROCESS_PRE_STOP);

789

TEST_EQ (ret, 0);

757

job_process_start (job, PROCESS_PRE_STOP);

790

758

791

759

TEST_NE (job->pid[PROCESS_PRE_STOP], 0);

792

760

843

811

"CRACKLE=FIZZ"));

844

812

}

845

813

846

ret = job_process_run (job, PROCESS_POST_STOP);

847

TEST_EQ (ret, 0);

814

job_process_start (job, PROCESS_POST_STOP);

848

815

849

816

TEST_NE (job->pid[PROCESS_POST_STOP], 0);

850

817

894

861

job->state = JOB_SPAWNED;

895

862

}

896

863

897

ret = job_process_run (job, PROCESS_MAIN);

898

TEST_EQ (ret, 0);

864

job_process_start (job, PROCESS_MAIN);

899

865

900

866

TEST_NE (job->pid[PROCESS_MAIN], 0);

901

867

902

/* Loop until we've fed all of the data. */

903

first = TRUE;

904

for (;;) {

905

fd_set readfds, writefds, exceptfds;

906

int nfds;

907

908

nfds = 0;

909

FD_ZERO (&readfds);

910

FD_ZERO (&writefds);

911

FD_ZERO (&exceptfds);

912

913

nih_io_select_fds (&nfds, &readfds,

914

&writefds, &exceptfds);

915

if (! nfds) {

916

if (first)

917

TEST_FAILED ("expected to have "

918

"data to feed.");

919

break;

920

}

921

first = FALSE;

922

923

select (nfds, &readfds, &writefds, &exceptfds, NULL);

924

925

nih_io_handle_fds (&readfds, &writefds, &exceptfds);

926

}

868

TEST_WATCH_LOOP ();

927

869

928

870

waitpid (job->pid[PROCESS_MAIN], &status, 0);

929

871

TEST_TRUE (WIFEXITED (status));

962

904

job->trace_state = TRACE_NORMAL;

963

905

}

964

906

965

ret = job_process_run (job, PROCESS_MAIN);

966

TEST_EQ (ret, 0);

907

job_process_start (job, PROCESS_MAIN);

967

908

968

909

TEST_EQ (job->trace_forks, 0);

969

910

TEST_EQ (job->trace_state, TRACE_NONE);

1002

943

job->trace_state = TRACE_NORMAL;

1003

944

}

1004

945

1005

ret = job_process_run (job, PROCESS_PRE_START);

1006

TEST_EQ (ret, 0);

946

job_process_start (job, PROCESS_PRE_START);

1007

947

1008

948

TEST_EQ (job->trace_forks, 0);

1009

949

TEST_EQ (job->trace_state, TRACE_NONE);

1044

984

job->trace_state = TRACE_NORMAL;

1045

985

}

1046

986

1047

ret = job_process_run (job, PROCESS_MAIN);

1048

TEST_EQ (ret, 0);

987

job_process_start (job, PROCESS_MAIN);

1049

988

1050

989

TEST_EQ (job->trace_forks, 0);

1051

990

TEST_EQ (job->trace_state, TRACE_NEW);

1095

1034

job->trace_state = TRACE_NORMAL;

1096

1035

}

1097

1036

1098

ret = job_process_run (job, PROCESS_MAIN);

1099

TEST_EQ (ret, 0);

1037

job_process_start (job, PROCESS_MAIN);

1100

1038

1101

1039

TEST_EQ (job->trace_forks, 0);

1102

1040

TEST_EQ (job->trace_state, TRACE_NEW);

1122

1060

}

1123

1061

1124

1062

/* Check that if we try and run a command that doesn't exist,

1125

* job_process_run() raises a ProcessError and the command doesn't

1063

* job_process_start() raises a ProcessError and the command doesn't

1126

1064

* have any stored process id for it.

1127

1065

*/

1128

1066

TEST_FEATURE ("with no such file");

1144

1082

}

1145

1083

1146

1084

TEST_DIVERT_STDERR (output) {

1147

ret = job_process_run (job, PROCESS_MAIN);

1085

job_process_start (job, PROCESS_MAIN);

1086

TEST_WATCH_LOOP ();

1087

event_poll ();

1148

1088

}

1149

1089

rewind (output);

1150

TEST_LT (ret, 0);

1151

1090

1152

1091

TEST_EQ (job->pid[PROCESS_MAIN], 0);

1153

1092

1154

1093

TEST_FILE_EQ (output, ("test: Failed to spawn test (foo) main "

1195

1134

job->goal = JOB_START;

1196

1135

job->state = JOB_SPAWNED;

1197

1136

1198

ret = job_process_run (job, PROCESS_MAIN);

1199

TEST_EQ (ret, 0);

1137

job_process_start (job, PROCESS_MAIN);

1200

1138

1201

1139

TEST_NE (job->pid[PROCESS_MAIN], 0);

1202

1140

1263

1201

job->goal = JOB_START;

1264

1202

job->state = JOB_SPAWNED;

1265

1203

1266

ret = job_process_run (job, PROCESS_MAIN);

1267

TEST_EQ (ret, 0);

1204

job_process_start (job, PROCESS_MAIN);

1268

1205

1269

1206

TEST_NE (job->pid[PROCESS_MAIN], 0);

1270

1207

1331

1268

job->goal = JOB_START;

1332

1269

job->state = JOB_SPAWNED;

1333

1270

1334

ret = job_process_run (job, PROCESS_MAIN);

1335

TEST_EQ (ret, 0);

1271

job_process_start (job, PROCESS_MAIN);

1336

1272

1337

1273

TEST_NE (job->pid[PROCESS_MAIN], 0);

1338

1274

1399

1335

job->goal = JOB_START;

1400

1336

job->state = JOB_SPAWNED;

1401

1337

1402

ret = job_process_run (job, PROCESS_MAIN);

1403

TEST_EQ (ret, 0);

1338

job_process_start (job, PROCESS_MAIN);

1404

1339

1405

1340

TEST_NE (job->pid[PROCESS_MAIN], 0);

1406

1341

1462

1397

job->goal = JOB_START;

1463

1398

job->state = JOB_SPAWNED;

1464

1399

1465

ret = job_process_run (job, PROCESS_MAIN);

1466

TEST_EQ (ret, 0);

1400

job_process_start (job, PROCESS_MAIN);

1467

1401

1468

1402

TEST_NE (job->pid[PROCESS_MAIN], 0);

1469

1403

1499

1433

job->goal = JOB_START;

1500

1434

job->state = JOB_SPAWNED;

1501

1435

1502

ret = job_process_run (job, PROCESS_MAIN);

1503

TEST_EQ (ret, 0);

1436

job_process_start (job, PROCESS_MAIN);

1504

1437

1505

1438

TEST_NE (job->pid[PROCESS_MAIN], 0);

1506

1439

1536

1469

job->goal = JOB_START;

1537

1470

job->state = JOB_SPAWNED;

1538

1471

1539

ret = job_process_run (job, PROCESS_MAIN);

1540

TEST_EQ (ret, 0);

1472

job_process_start (job, PROCESS_MAIN);

1541

1473

1542

1474

TEST_NE (job->pid[PROCESS_MAIN], 0);

1543

1475

1583

1515

job->goal = JOB_START;

1584

1516

job->state = JOB_SPAWNED;

1585

1517

1586

ret = job_process_run (job, PROCESS_MAIN);

1587

TEST_EQ (ret, 0);

1518

job_process_start (job, PROCESS_MAIN);

1588

1519

1589

1520

TEST_NE (job->pid[PROCESS_MAIN], 0);

1590

1521

1522

/* XXX: call 0: async process setup */

1523

TEST_WATCH_UPDATE ();

1524

1591

1525

/* XXX: call 1: wait for script write to child shell */

1592

1526

TEST_WATCH_UPDATE ();

1593

1527

1613

1547

1614

1548

/* Note we can't use TEST_ALLOC_FAIL() for this test since on

1615

1549

* the ENOMEM loop all we could do is discard the error and

1616

* continue since job_process_run() calls job_process_spawn()

1550

* continue since job_process_start() calls job_process_spawn()

1617

1551

* repeatedly until it works, but the alloc fails in log_new()

1618

1552

* invoked by job_process_spawn() such that when we've left

1619

* job_process_run(), it's too late.

1553

* job_process_start(), it's too late.

1620

1554

*

1621

1555

* However, we test this scenario in test_spawn() so all is not

1622

1556

* lost.

1637

1571

job->goal = JOB_START;

1638

1572

job->state = JOB_SPAWNED;

1639

1573

1640

ret = job_process_run (job, PROCESS_MAIN);

1641

TEST_EQ (ret, 0);

1574

job_process_start (job, PROCESS_MAIN);

1642

1575

1643

1576

TEST_NE (job->pid[PROCESS_MAIN], 0);

1644

1577

1695

1628

job->goal = JOB_START;

1696

1629

job->state = JOB_SPAWNED;

1697

1630

1698

ret = job_process_run (job, PROCESS_MAIN);

1699

TEST_EQ (ret, 0);

1631

job_process_start (job, PROCESS_MAIN);

1700

1632

1701

1633

TEST_NE (job->pid[PROCESS_MAIN], 0);

1702

1634

1635

/* wait for process to setup */

1636

TEST_WATCH_UPDATE ();

1637

1703

1638

/* wait for read from pty allowing logger to write to log file */

1704

1639

TEST_WATCH_UPDATE ();

1705

1640

1779

1714

job->goal = JOB_START;

1780

1715

job->state = JOB_SPAWNED;

1781

1716

1782

ret = job_process_run (job, PROCESS_MAIN);

1783

TEST_EQ (ret, 0);

1717

job_process_start (job, PROCESS_MAIN);

1784

1718

1785

1719

TEST_NE (job->pid[PROCESS_MAIN], 0);

1786

1720

1721

/* wait for process to setup */

1722

TEST_WATCH_UPDATE ();

1723

1787

1724

/* wait for read from pty allowing logger to write to log file */

1788

1725

TEST_WATCH_UPDATE ();

1789

1726

1861

1798

1862

1799

/* Note we can't use TEST_ALLOC_FAIL() for this test since on

1863

1800

* the ENOMEM loop all we could do is discard the error and

1864

* continue since job_process_run() calls job_process_spawn()

1801

* continue since job_process_start() calls job_process_spawn()

1865

1802

* repeatedly until it works, but the alloc fails in log_new()

1866

1803

* invoked by job_process_spawn() such that when we've left

1867

* job_process_run(), it's too late.

1804

* job_process_start(), it's too late.

1868

1805

*

1869

1806

* However, we test this scenario in test_spawn() so all is not

1870

1807

* lost.

1885

1822

job->goal = JOB_START;

1886

1823

job->state = JOB_SPAWNED;

1887

1824

1888

ret = job_process_run (job, PROCESS_MAIN);

1889

TEST_EQ (ret, 0);

1825

job_process_start (job, PROCESS_MAIN);

1890

1826

1891

1827

TEST_NE (job->pid[PROCESS_MAIN], 0);

1892

1828

1829

/* wait for process to setup */

1830

TEST_WATCH_UPDATE ();

1831

1893

1832

/* XXX: call 1: wait for script write to child shell */

1894

1833

TEST_WATCH_UPDATE ();

1895

1834

1948

1887

job->goal = JOB_START;

1949

1888

job->state = JOB_SPAWNED;

1950

1889

1951

ret = job_process_run (job, PROCESS_MAIN);

1952

TEST_EQ (ret, 0);

1890

job_process_start (job, PROCESS_MAIN);

1953

1891

1954

1892

TEST_NE (job->pid[PROCESS_MAIN], 0);

1955

1893

1894

/* wait for process to setup */

1895

TEST_WATCH_UPDATE ();

1896

1956

1897

/* wait for read from pty allowing logger to write to log file */

1957

1898

TEST_WATCH_UPDATE ();

1958

1899

2017

1958

job->goal = JOB_START;

2018

1959

job->state = JOB_SPAWNED;

2019

1960

2020

ret = job_process_run (job, PROCESS_MAIN);

2021

TEST_EQ (ret, 0);

1961

job_process_start (job, PROCESS_MAIN);

2022

1962

2023

1963

TEST_NE (job->pid[PROCESS_MAIN], 0);

2024

1964

1965

/* wait for process to setup */

1966

TEST_WATCH_UPDATE ();

1967

2025

1968

/* XXX: call 1: wait for script write to child shell */

2026

1969

TEST_WATCH_UPDATE ();

2027

1970

2064

2007

2065

2008

/* Note we can't use TEST_ALLOC_FAIL() for this test since on

2066

2009

* the ENOMEM loop all we could do is discard the error and

2067

* continue since job_process_run() calls job_process_spawn()

2010

* continue since job_process_start() calls job_process_spawn()

2068

2011

* repeatedly until it works, but the alloc fails in log_new()

2069

2012

* invoked by job_process_spawn() such that when we've left

2070

* job_process_run(), it's too late.

2013

* job_process_start(), it's too late.

2071

2014

*

2072

2015

* However, we test this scenario in test_spawn() so all is not

2073

2016

* lost.

2088

2031

job->goal = JOB_START;

2089

2032

job->state = JOB_SPAWNED;

2090

2033

2091

ret = job_process_run (job, PROCESS_MAIN);

2092

TEST_EQ (ret, 0);

2034

job_process_start (job, PROCESS_MAIN);

2093

2035

2094

2036

TEST_NE (job->pid[PROCESS_MAIN], 0);

2095

2037

2135

2077

* XXX: TEST_WATCH_UPDATE() *TWICE* to ensure select(2) is

2136

2078

* XXX: called twice.

2137

2079

*

2138

* This is required since job_process_run() uses an NihIo object

2080

* This is required since job_process_start() uses an NihIo object

2139

2081

* to squirt the script to the shell sub-process and this

2140

2082

* triggers select to return when the data is written to the shell.

2141

2083

* However, we don't care about that directly - we care more about

2144

2086

* written.

2145

2087

*

2146

2088

* Note that the 2nd call to TEST_WATCH_UPDATE would not be

2147

* required should job_process_run() simple invoke write(2) to

2089

* required should job_process_start() simple invoke write(2) to

2148

2090

* send the data.

2149

2091

*/

2150

2092

2165

2107

job->goal = JOB_START;

2166

2108

job->state = JOB_SPAWNED;

2167

2109

2168

ret = job_process_run (job, PROCESS_MAIN);

2169

TEST_EQ (ret, 0);

2110

job_process_start (job, PROCESS_MAIN);

2170

2111

2171

2112

TEST_NE (job->pid[PROCESS_MAIN], 0);

2172

2113

2114

/* wait for process to setup */

2115

TEST_WATCH_UPDATE ();

2116

2173

2117

/* XXX: call 1: wait for script write to child shell */

2174

2118

TEST_WATCH_UPDATE ();

2175

2119

2227

2171

job->goal = JOB_START;

2228

2172

job->state = JOB_SPAWNED;

2229

2173

2230

ret = job_process_run (job, PROCESS_MAIN);

2231

TEST_EQ (ret, 0);

2174

job_process_start (job, PROCESS_MAIN);

2232

2175

2233

2176

TEST_NE (job->pid[PROCESS_MAIN], 0);

2234

2177

2287

2230

job->goal = JOB_START;

2288

2231

job->state = JOB_SPAWNED;

2289

2232

2290

ret = job_process_run (job, PROCESS_MAIN);

2291

TEST_EQ (ret, 0);

2233

job_process_start (job, PROCESS_MAIN);

2292

2234

2293

2235

TEST_NE (job->pid[PROCESS_MAIN], 0);

2294

2236

2352

2294

job->goal = JOB_START;

2353

2295

job->state = JOB_SPAWNED;

2354

2296

2355

ret = job_process_run (job, PROCESS_MAIN);

2356

TEST_EQ (ret, 0);

2297

job_process_start (job, PROCESS_MAIN);

2357

2298

2358

2299

TEST_NE (job->pid[PROCESS_MAIN], 0);

2359

2300

2414

2355

job->goal = JOB_START;

2415

2356

job->state = JOB_SPAWNED;

2416

2357

2417

ret = job_process_run (job, PROCESS_MAIN);

2418

TEST_EQ (ret, 0);

2358

job_process_start (job, PROCESS_MAIN);

2419

2359

2420

2360

TEST_NE (job->pid[PROCESS_MAIN], 0);

2421

2361

2422

2362

TEST_WATCH_UPDATE ();

2363

TEST_WATCH_UPDATE ();

2423

2364

waitpid (job->pid[PROCESS_MAIN], &status, 0);

2424

2365

TEST_TRUE (WIFEXITED (status));

2425

2366

TEST_EQ (WEXITSTATUS (status), 0);

2474

2415

job->goal = JOB_START;

2475

2416

job->state = JOB_SPAWNED;

2476

2417

2477

ret = job_process_run (job, PROCESS_MAIN);

2478

TEST_EQ (ret, 0);

2418

job_process_start (job, PROCESS_MAIN);

2479

2419

2480

2420

TEST_NE (job->pid[PROCESS_MAIN], 0);

2481

2421

2537

2477

job->goal = JOB_START;

2538

2478

job->state = JOB_SPAWNED;

2539

2479

2540

ret = job_process_run (job, PROCESS_MAIN);

2541

TEST_EQ (ret, 0);

2480

job_process_start (job, PROCESS_MAIN);

2542

2481

2543

2482

TEST_NE (job->pid[PROCESS_MAIN], 0);

2544

2483

2597

2536

job->goal = JOB_START;

2598

2537

job->state = JOB_SPAWNED;

2599

2538

2600

ret = job_process_run (job, PROCESS_MAIN);

2601

TEST_EQ (ret, 0);

2539

job_process_start (job, PROCESS_MAIN);

2602

2540

2603

2541

TEST_NE (job->pid[PROCESS_MAIN], 0);

2604

2542

2605

2543

TEST_WATCH_UPDATE ();

2544

TEST_WATCH_UPDATE ();

2606

2545

2607

2546

waitpid (job->pid[PROCESS_MAIN], &status, 0);

2608

2547

TEST_TRUE (WIFEXITED (status));

2659

2598

job->goal = JOB_START;

2660

2599

job->state = JOB_SPAWNED;

2661

2600

2662

ret = job_process_run (job, PROCESS_MAIN);

2663

TEST_EQ (ret, 0);

2601

job_process_start (job, PROCESS_MAIN);

2664

2602

2665

2603

TEST_NE (job->pid[PROCESS_MAIN], 0);

2666

2604

2725

2663

job->goal = JOB_START;

2726

2664

job->state = JOB_SPAWNED;

2727

2665

2728

ret = job_process_run (job, PROCESS_MAIN);

2729

TEST_EQ (ret, 0);

2666

job_process_start (job, PROCESS_MAIN);

2730

2667

2731

2668

TEST_NE (job->pid[PROCESS_MAIN], 0);

2732

2669

2787

2724

job->goal = JOB_START;

2788

2725

job->state = JOB_SPAWNED;

2789

2726

2790

ret = job_process_run (job, PROCESS_MAIN);

2791

TEST_EQ (ret, 0);

2727

job_process_start (job, PROCESS_MAIN);

2792

2728

2793

2729

TEST_NE (job->pid[PROCESS_MAIN], 0);

2794

2730

2795

2731

TEST_WATCH_UPDATE ();

2732

TEST_WATCH_UPDATE ();

2796

2733

2797

2734

waitpid (job->pid[PROCESS_MAIN], &status, 0);

2798

2735

TEST_TRUE (WIFEXITED (status));

2851

2788

job->goal = JOB_START;

2852

2789

job->state = JOB_SPAWNED;

2853

2790

2854

ret = job_process_run (job, PROCESS_MAIN);

2855

TEST_EQ (ret, 0);

2791

job_process_start (job, PROCESS_MAIN);

2856

2792

2857

2793

TEST_NE (job->pid[PROCESS_MAIN], 0);

2858

2794

2913

2849

job->goal = JOB_START;

2914

2850

job->state = JOB_SPAWNED;

2915

2851

2916

ret = job_process_run (job, PROCESS_MAIN);

2917

TEST_EQ (ret, 0);

2852

job_process_start (job, PROCESS_MAIN);

2918

2853

2919

2854

TEST_NE (job->pid[PROCESS_MAIN], 0);

2920

2855

2973

2908

job->goal = JOB_START;

2974

2909

job->state = JOB_SPAWNED;

2975

2910

2976

ret = job_process_run (job, PROCESS_MAIN);

2977

TEST_EQ (ret, 0);

2911

job_process_start (job, PROCESS_MAIN);

2978

2912

2979

2913

TEST_NE (job->pid[PROCESS_MAIN], 0);

2980

2914

3037

2971

job->goal = JOB_START;

3038

2972

job->state = JOB_SPAWNED;

3039

2973

3040

ret = job_process_run (job, PROCESS_MAIN);

3041

TEST_EQ (ret, 0);

2974

job_process_start (job, PROCESS_MAIN);

3042

2975

3043

2976

TEST_NE (job->pid[PROCESS_MAIN], 0);

3044

2977

3112

3045

output = tmpfile ();

3113

3046

TEST_NE_P (output, NULL);

3114

3047

TEST_DIVERT_STDERR (output) {

3115

ret = job_process_run (job, PROCESS_MAIN);

3116

TEST_LT (ret, 0);

3048

job_process_start (job, PROCESS_MAIN);

3049

TEST_WATCH_UPDATE ();

3050

event_poll ();

3117

3051

}

3118

3052

fclose (output);

3119

3053

3161

3095

job->goal = JOB_START;

3162

3096

job->state = JOB_SPAWNED;

3163

3097

3164

ret = job_process_run (job, PROCESS_MAIN);

3165

TEST_LT (ret, 0);

3098

job_process_start (job, PROCESS_MAIN);

3099

TEST_WATCH_UPDATE ();

3166

3100

3167

3101

/* We don't expect a logfile to be written since there is no

3168

3102

* accompanying shell to write the error.

3173

3107

job->goal = JOB_STOP;

3174

3108

job->state = JOB_POST_STOP;

3175

3109

3176

ret = job_process_run (job, PROCESS_POST_STOP);

3177

TEST_EQ (ret, 0);

3110

job_process_start (job, PROCESS_POST_STOP);

3178

3111

3179

3112

TEST_NE (job->pid[PROCESS_POST_STOP], 0);

3113

TEST_WATCH_UPDATE ();

3180

3114

3181

3115

/* Flush the io so that the shell on the client side

3182

3116

* gets the data (the script to execute).

3187

3121

TEST_TRUE (WIFEXITED (status));

3188

3122

TEST_EQ (WEXITSTATUS (status), 0);

3189

3123

3124

TEST_WATCH_UPDATE ();

3125

3190

3126

/* .. but the post stop should have written data */

3191

3127

TEST_EQ (stat (filename, &statbuf), 0);

3128

event_poll ();

3192

3129

}

3193

3130

fclose (output);

3194

3131

3241

3178

job->goal = JOB_START;

3242

3179

job->state = JOB_SPAWNED;

3243

3180

3244

ret = job_process_run (job, PROCESS_MAIN);

3245

TEST_LT (ret, 0);

3181

job_process_start (job, PROCESS_MAIN);

3182

TEST_WATCH_UPDATE ();

3183

TEST_WATCH_UPDATE ();

3246

3184

3247

3185

/* We don't expect a logfile to be written since there is no

3248

3186

* accompanying shell to write the error.

3253

3191

job->goal = JOB_STOP;

3254

3192

job->state = JOB_POST_STOP;

3255

3193

3256

ret = job_process_run (job, PROCESS_POST_STOP);

3257

TEST_EQ (ret, 0);

3194

job_process_start (job, PROCESS_POST_STOP);

3195

TEST_WATCH_UPDATE ();

3258

3196

3259

3197

TEST_NE (job->pid[PROCESS_POST_STOP], 0);

3260

3198

3272

3210

3273

3211

/* .. but the post stop should have written data */

3274

3212

TEST_EQ (stat (filename, &statbuf), 0);

3213

event_poll ();

3275

3214

}

3276

3215

fclose (output);

3277

3216

3325

3264

job->goal = JOB_START;

3326

3265

job->state = JOB_SPAWNED;

3327

3266

3328

ret = job_process_run (job, PROCESS_MAIN);

3329

TEST_LT (ret, 0);

3267

job_process_start (job, PROCESS_MAIN);

3268

TEST_WATCH_UPDATE ();

3330

3269

3331

3270

/* We don't expect a logfile to be written since there is no

3332

3271

* accompanying shell to write the error.

3337

3276

job->goal = JOB_STOP;

3338

3277

job->state = JOB_POST_STOP;

3339

3278

3340

ret = job_process_run (job, PROCESS_POST_STOP);

3341

TEST_EQ (ret, 0);

3279

job_process_start (job, PROCESS_POST_STOP);

3280

TEST_WATCH_UPDATE ();

3342

3281

3343

3282

TEST_NE (job->pid[PROCESS_POST_STOP], 0);

3344

3283

3351

3290

TEST_TRUE (WIFEXITED (status));

3352

3291

TEST_EQ (WEXITSTATUS (status), 0);

3353

3292

3293

TEST_WATCH_UPDATE ();

3294

3354

3295

/* .. but the post stop should have written data */

3355

3296

TEST_EQ (stat (filename, &statbuf), 0);

3297

event_poll ();

3356

3298

}

3357

3299

fclose (output);

3358

3300

3405

3347

job->goal = JOB_START;

3406

3348

job->state = JOB_SPAWNED;

3407

3349

3408

ret = job_process_run (job, PROCESS_MAIN);

3409

TEST_LT (ret, 0);

3350

job_process_start (job, PROCESS_MAIN);

3351

TEST_WATCH_UPDATE ();

3410

3352

3411

3353

/* We don't expect a logfile to be written since there is no

3412

3354

* accompanying shell to write the error.

3417

3359

job->goal = JOB_STOP;

3418

3360

job->state = JOB_POST_STOP;

3419

3361

3420

ret = job_process_run (job, PROCESS_POST_STOP);

3421

TEST_LT (ret, 0);

3362

job_process_start (job, PROCESS_POST_STOP);

3363

TEST_WATCH_UPDATE ();

3422

3364

3423

3365

/* Again, no file expected */

3424

3366

TEST_EQ (stat (filename, &statbuf), -1);

3425

3367

TEST_EQ (errno, ENOENT);

3368

event_poll ();

3426

3369

}

3427

3370

fclose (output);

3428

3371

nih_free (class);

3463

3406

job->goal = JOB_START;

3464

3407

job->state = JOB_SPAWNED;

3465

3408

3466

ret = job_process_run (job, PROCESS_MAIN);

3467

TEST_EQ (ret, 0);

3409

job_process_start (job, PROCESS_MAIN);

3468

3410

3469

3411

TEST_NE (job->pid[PROCESS_MAIN], 0);

3470

3412

3483

3425

job->goal = JOB_STOP;

3484

3426

job->state = JOB_POST_STOP;

3485

3427

3486

ret = job_process_run (job, PROCESS_POST_STOP);

3487

TEST_LT (ret, 0);

3428

job_process_start (job, PROCESS_POST_STOP);

3429

TEST_WATCH_UPDATE ();

3488

3430

3489

3431

TEST_EQ (job->pid[PROCESS_POST_STOP], 0);

3490

3432

}

3524

3466

job->goal = JOB_START;

3525

3467

job->state = JOB_SPAWNED;

3526

3468

3527

ret = job_process_run (job, PROCESS_MAIN);

3528

TEST_EQ (ret, 0);

3469

job_process_start (job, PROCESS_MAIN);

3470

TEST_WATCH_UPDATE ();

3529

3471

3530

3472

TEST_NE (job->pid[PROCESS_MAIN], 0);

3531

3473

3585

3527

job->goal = JOB_START;

3586

3528

job->state = JOB_SPAWNED;

3587

3529

3588

ret = job_process_run (job, PROCESS_MAIN);

3589

TEST_EQ (ret, 0);

3530

job_process_start (job, PROCESS_MAIN);

3531

TEST_WATCH_UPDATE ();

3590

3532

3591

3533

TEST_NE (job->pid[PROCESS_MAIN], 0);

3592

3534

3648

3590

job->goal = JOB_START;

3649

3591

job->state = JOB_SPAWNED;

3650

3592

3651

ret = job_process_run (job, PROCESS_MAIN);

3652

TEST_EQ (ret, 0);

3593

job_process_start (job, PROCESS_MAIN);

3594

TEST_WATCH_UPDATE ();

3653

3595

3654

3596

TEST_NE (job->pid[PROCESS_MAIN], 0);

3655

3597

3728

3670

job->goal = JOB_START;

3729

3671

job->state = JOB_SPAWNED;

3730

3672

3731

ret = job_process_run (job, PROCESS_MAIN);

3732

TEST_EQ (ret, 0);

3673

job_process_start (job, PROCESS_MAIN);

3733

3674

3734

3675

/* Wait for process to avoid any possibility of EAGAIN in

3735

3676

* log_read_watch().

3802

3743

job->goal = JOB_START;

3803

3744

job->state = JOB_SPAWNED;

3804

3745

3805

ret = job_process_run (job, PROCESS_MAIN);

3806

TEST_EQ (ret, 0);

3746

job_process_start (job, PROCESS_MAIN);

3747

TEST_WATCH_UPDATE ();

3748

TEST_WATCH_UPDATE ();

3807

3749

3808

3750

pid = job->pid[PROCESS_MAIN];

3809

3751

3933

3875

TEST_EQ_P (job->log[i], NULL);

3934

3876

}

3935

3877

3936

ret = job_process_run (job, PROCESS_MAIN);

3937

TEST_EQ (ret, 0);

3878

job_process_start (job, PROCESS_MAIN);

3879

TEST_WATCH_UPDATE ();

3938

3880

3939

3881

pid = job->pid[PROCESS_MAIN];

3940

3882

4006

3948

}

4007

3949

4008

3950

TEST_DIVERT_STDERR (output) {

4009

ret = job_process_run (job, PROCESS_MAIN);

4010

TEST_EQ (ret, 0);

3951

job_process_start (job, PROCESS_MAIN);

4011

3952

}

4012

3953

fclose (output);

4013

3954

4064

4005

}

4065

4006

4066

4007

TEST_DIVERT_STDERR (output) {

4067

ret = job_process_run (job, PROCESS_MAIN);

4068

if (geteuid() == 0 || getuid() == pwd->pw_uid) {

4069

TEST_EQ (ret, 0);

4070

}

4071

else {

4072

TEST_EQ (ret, -1);

4073

}

4008

job_process_start (job, PROCESS_MAIN);

4009

TEST_WATCH_UPDATE ();

4074

4010

}

4075

4011

4076

4012

if (geteuid() == 0 || getuid() == pwd->pw_uid) {

4081

4017

}

4082

4018

else {

4083

4019

TEST_EQ (stat (filename, &statbuf), -1);

4020

event_poll ();

4084

4021

}

4085

4022

4086

4023

unlink (filename);

4087

4024

nih_free (class);

4088

4089

4025

}

4090

4026

4027

/* FIXME with async spawn this test is racy */

4028

4091

4029

/************************************************************/

4092

4030

TEST_FEATURE ("with multiple processes and log");

4093

4031

TEST_HASH_EMPTY (job_classes);

4128

4066

job->goal = JOB_START;

4129

4067

job->state = JOB_SPAWNED;

4130

4068

4131

ret = job_process_run (job, PROCESS_MAIN);

4132

TEST_EQ (ret, 0);

4133

4069

job_process_start (job, PROCESS_MAIN);

4070

while (stat (filename, &statbuf) != 0) {

4071

TEST_WATCH_UPDATE ();

4072

}

4134

4073

pid = job->pid[PROCESS_MAIN];

4135

4074

TEST_GT (pid, 0);

4136

4075

4137

TEST_WATCH_UPDATE ();

4138

4139

4076

TEST_EQ (stat (filename, &statbuf), 0);

4140

4077

4141

4078

output = fopen (filename, "r");

4148

4085

4149

4086

TEST_EQ (fclose (output), 0);

4150

4087

4151

ret = job_process_run (job, PROCESS_POST_START);

4152

TEST_EQ (ret, 0);

4088

job_process_start (job, PROCESS_POST_START);

4089

TEST_WATCH_UPDATE ();

4153

4090

4154

4091

pid = job->pid[PROCESS_POST_START];

4155

4092

TEST_GT (pid, 0);

4244

4181

int status;

4245

4182

struct stat statbuf;

4246

4183

int ret;

4184

int job_process_fd = -1;

4185

nih_local NihIoBuffer *buffer = NULL;

4247

4186

4248

4187

log_unflushed_init ();

4249

4188

4257

4196

*/

4258

4197

TEST_EQ (setenv ("UPSTART_LOGDIR", dirname, 1), 0);

4259

4198

4260

TEST_FUNCTION ("job_process_spawn");

4199

TEST_FUNCTION ("job_process_spawn_with_fd");

4261

4200

TEST_FILENAME (filename);

4262

4201

4263

4202

args[0] = argv0;

4278

4217

class->console = CONSOLE_NONE;

4279

4218

job = job_new (class, "");

4280

4219

4281

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4220

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4282

4221

TEST_GT (pid, 0);

4283

4222

4284

4223

waitpid (pid, NULL, 0);

4319

4258

class->console = CONSOLE_NONE;

4320

4259

job = job_new (class, "");

4321

4260

4322

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4261

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4323

4262

TEST_GT (pid, 0);

4324

4263

4325

4264

waitpid (pid, NULL, 0);

4351

4290

class->console = CONSOLE_LOG;

4352

4291

job = job_new (class, "");

4353

4292

4354

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4293

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4355

4294

TEST_GT (pid, 0);

4356

4295

4357

4296

waitpid (pid, NULL, 0);

4398

4337

class->chdir = "/tmp";

4399

4338

job = job_new (class, "");

4400

4339

4401

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4340

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4402

4341

TEST_GT (pid, 0);

4403

4342

4404

4343

waitpid (pid, NULL, 0);

4430

4369

class->console = CONSOLE_NONE;

4431

4370

job = job_new (class, "");

4432

4371

4433

pid = job_process_spawn (job, args, env, FALSE, -1, PROCESS_MAIN);

4372

pid = job_process_spawn_with_fd (job, args, env, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4434

4373

TEST_GT (pid, 0);

4435

4374

4436

4375

waitpid (pid, NULL, 0);

4460

4399

class->console = CONSOLE_NONE;

4461

4400

job = job_new (class, "");

4462

4401

4463

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4402

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4464

4403

TEST_GT (pid, 0);

4465

4404

4466

4405

assert0 (waitid (P_PID, pid, &info, WEXITED | WSTOPPED | WCONTINUED));

4483

4422

class = job_class_new (NULL, "test", NULL);

4484

4423

job = job_new (class, "");

4485

4424

class->console = CONSOLE_NONE;

4486

pid = job_process_spawn (job, args, NULL, TRUE, -1, PROCESS_MAIN);

4425

pid = job_process_spawn_with_fd (job, args, NULL, TRUE, -1, PROCESS_MAIN, &job_process_fd);

4487

4426

TEST_GT (pid, 0);

4488

4427

4489

4428

assert0 (waitid (P_PID, pid, &info, WEXITED | WSTOPPED | WCONTINUED));

4516

4455

class->console = CONSOLE_NONE;

4517

4456

job = job_new (class, "");

4518

4457

4519

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4520

TEST_LT (pid, 0);

4458

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4459

TEST_NE (pid, 0);

4460

4461

buffer = read_from_fd (NULL, job_process_fd);

4462

TEST_NE_P (buffer, NULL);

4463

job_process_error_handler (buffer->buf, buffer->len);

4521

4464

4522

4465

err = nih_error_get ();

4523

4466

TEST_EQ (err->number, JOB_PROCESS_ERROR);

4528

4471

TEST_EQ (perr->arg, 0);

4529

4472

TEST_EQ (perr->errnum, ENOENT);

4530

4473

nih_free (perr);

4474

nih_free (buffer);

4531

4475

4532

4476

/************************************************************/

4533

4477

TEST_FEATURE ("with no such file, no shell and console log");

4539

4483

class = job_class_new (NULL, "test", NULL);

4540

4484

class->console = CONSOLE_LOG;

4541

4485

job = job_new (class, "");

4486

job->goal = JOB_START;

4487

job->state = JOB_SPAWNED;

4542

4488

4543

4489

TEST_NE_P (job->log, NULL);

4544

4490

TEST_EQ_P (job->log[PROCESS_MAIN], NULL);

4545

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4546

TEST_LT (pid, 0);

4491

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4492

job->process_data[PROCESS_MAIN] = NIH_MUST (

4493

job_process_data_new (job->process_data, job, PROCESS_MAIN, job_process_fd));

4494

TEST_WATCH_UPDATE ();

4495

TEST_NE (pid, 0);

4547

4496

4548

4497

TEST_GT (waitpid (-1, NULL, 0), 0);

4549

4498

4499

NihIo *io = nih_io_reopen (job, job_process_fd, NIH_IO_STREAM, NULL, NULL, NULL, NULL);

4500

TEST_NE_P (io, NULL);

4501

buffer = read_from_fd (NULL, job_process_fd);

4502

TEST_NE_P (buffer, NULL);

4503

TEST_NE_P (job->process_data[PROCESS_MAIN], NULL);

4504

TEST_TRUE (job->process_data[PROCESS_MAIN]->valid);

4505

4506

4507

TEST_NE_P (job->log[PROCESS_MAIN], NULL);

4508

4509

job_process_child_reader (job->process_data[PROCESS_MAIN], io, buffer->buf, buffer->len);

4510

4550

4511

/* The log should have been allocated in job_process_spawn,

4551

4512

* but then freed on error.

4552

4513

*/

4553

4514

TEST_EQ_P (job->log[PROCESS_MAIN], NULL);

4554

4515

4555

err = nih_error_get ();

4556

TEST_EQ (err->number, JOB_PROCESS_ERROR);

4557

TEST_ALLOC_SIZE (err, sizeof (JobProcessError));

4558

4559

perr = (JobProcessError *)err;

4560

TEST_EQ (perr->type, JOB_PROCESS_ERROR_EXEC);

4561

TEST_EQ (perr->arg, 0);

4562

TEST_EQ (perr->errnum, ENOENT);

4563

nih_free (perr);

4564

4565

4516

/* Check that we can spawn a job and pause it

4566

4517

*/

4567

4518

TEST_FEATURE ("with debug enabled");

4577

4528

args[1] = function;

4578

4529

args[2] = NULL;

4579

4530

4580

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4531

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4581

4532

TEST_GT (pid, 0);

4582

4533

4583

4534

/* Ensure process is still running after some period of time.

4614

4565

class->console = CONSOLE_NONE;

4615

4566

job = job_new (class, "");

4616

4567

4617

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4568

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4618

4569

TEST_GT (pid, 0);

4619

4570

4620

4571

waitpid (pid, NULL, 0);

4669

4620

class->console = CONSOLE_LOG;

4670

4621

job = job_new (class, "");

4671

4622

4672

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

4623

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4673

4624

TEST_GT (pid, 0);

4674

4625

4675

4626

waitpid (pid, NULL, 0);

4742

4693

args[2] = filebuf;

4743

4694

args[3] = NULL;

4744

4695

4745

job->pid[PROCESS_MAIN] = job_process_spawn (job, args, NULL,

4746

FALSE, -1, PROCESS_MAIN);

4696

job->pid[PROCESS_MAIN] = job_process_spawn_with_fd (job, args, NULL,

4697

FALSE, -1, PROCESS_MAIN, &job_process_fd);

4747

4698

pid = job->pid[PROCESS_MAIN];

4748

4699

TEST_GT (pid, 0);

4749

4700

4769

4720

args[2] = filebuf;

4770

4721

args[3] = NULL;

4771

4722

4772

job->pid[PROCESS_POST_START] = job_process_spawn (job, args, NULL,

4773

FALSE, -1, PROCESS_POST_START);

4723

job->pid[PROCESS_POST_START] = job_process_spawn_with_fd (job, args, NULL,

4724

FALSE, -1, PROCESS_POST_START, &job_process_fd);

4774

4725

pid = job->pid[PROCESS_POST_START];

4775

4726

TEST_GT (pid, 0);

4776

4727

4867

4818

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, script));

4868

4819

}

4869

4820

4870

pid = job_process_spawn (job, args_array, NULL, FALSE, -1, PROCESS_MAIN);

4821

pid = job_process_spawn_with_fd (job, args_array, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4871

4822

4872

4823

if (test_alloc_failed) {

4873

4824

TEST_LT (pid, 0);

4934

4885

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, TEST_SHELL_ARG));

4935

4886

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, script));

4936

4887

4937

pid = job_process_spawn (job, args_array, NULL, FALSE, -1, PROCESS_MAIN);

4888

pid = job_process_spawn_with_fd (job, args_array, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4938

4889

TEST_GT (pid, 0);

4939

4890

4940

4891

TEST_EQ (waitpid (pid, &status, 0), pid);

4990

4941

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, TEST_SHELL_ARG));

4991

4942

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, script));

4992

4943

4993

pid = job_process_spawn (job, args_array, NULL, FALSE, -1, PROCESS_MAIN);

4944

pid = job_process_spawn_with_fd (job, args_array, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

4994

4945

TEST_GT (pid, 0);

4995

4946

4996

4947

TEST_EQ (waitpid (pid, &status, 0), pid);

5043

4994

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, "-en"));

5044

4995

NIH_MUST (nih_str_array_add (&args_array, NULL, &argc, "\\000"));

5045

4996

5046

pid = job_process_spawn (job, args_array, NULL, FALSE, -1, PROCESS_MAIN);

4997

pid = job_process_spawn_with_fd (job, args_array, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

5047

4998

TEST_GT (pid, 0);

5048

4999

5049

5000

TEST_EQ (waitpid (pid, &status, 0), pid);

5098

5049

args[3] = filebuf;

5099

5050

args[4] = NULL;

5100

5051

5101

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

5052

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

5102

5053

TEST_GT (pid, 0);

5103

5054

5104

5055

TEST_NE (waitpid (pid, &status, 0), -1);

5161

5112

args[3] = filebuf;

5162

5113

args[4] = NULL;

5163

5114

5164

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

5115

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

5165

5116

TEST_GT (pid, 0);

5166

5117

5167

5118

TEST_WATCH_UPDATE ();

5243

5194

}

5244

5195

}

5245

5196

5246

pid = job_process_spawn (job, args, NULL, FALSE, -1, PROCESS_MAIN);

5247

TEST_LT (pid, 0);

5197

pid = job_process_spawn_with_fd (job, args, NULL, FALSE, -1, PROCESS_MAIN, &job_process_fd);

5198

TEST_WATCH_UPDATE ();

5199

TEST_NE (pid, 0);

5200

5201

buffer = read_from_fd (NULL, job_process_fd);

5202

TEST_NE_P (buffer, NULL);

5203

job_process_error_handler (buffer->buf, buffer->len);

5248

5204

5249

5205

/* Ensure logging disabled in failure scenarios */

5250

5206

TEST_EQ (class->console, CONSOLE_NONE);

5830

5786

job->exit_status = 0;

5831

5787

5832

5788

job_process_handler (NULL, 1, NIH_CHILD_EXITED, 0);

5789

TEST_EQ (job->state, JOB_SPAWNED);

5790

job_change_state (job, job_next_state(job));

5833

5791

5834

5792

TEST_EQ (job->goal, JOB_START);

5835

5793

TEST_EQ (job->state, JOB_RUNNING);

9181

9139

void

9182

9140

run_tests (void)

9183

9141

{

9184

test_run ();

9142

test_start ();

9185

9143

test_spawn ();

9186

9144

test_log_path ();

9187

9145

test_kill ();