This patch is used to create a new sub package libpam-xtests to do more checks.

Upstream-Status: Pending

Signed-off-by: Kang Kai <kai.kang@windriver.com>
Index: Linux-PAM-1.3.0/xtests/Makefile.am
===================================================================
--- Linux-PAM-1.3.0.orig/xtests/Makefile.am
+++ Linux-PAM-1.3.0/xtests/Makefile.am
@@ -7,7 +7,7 @@ AM_CFLAGS = -DLIBPAM_COMPILE -I$(top_src
 LDADD = $(top_builddir)/libpam/libpam.la \
 	$(top_builddir)/libpam_misc/libpam_misc.la
 
-CLEANFILES = *~ $(XTESTS)
+CLEANFILES = *~
 
 EXTRA_DIST = run-xtests.sh tst-pam_dispatch1.pamd tst-pam_dispatch2.pamd \
 	tst-pam_dispatch3.pamd tst-pam_dispatch4.pamd \
@@ -51,3 +51,18 @@ EXTRA_PROGRAMS = $(XTESTS)
 
 xtests: $(XTESTS) run-xtests.sh
 	"$(srcdir)"/run-xtests.sh "$(srcdir)" ${XTESTS} ${NOSRCTESTS}
+
+all: $(XTESTS)
+
+install: install_xtests
+
+install_xtests:
+	$(INSTALL) -d $(DESTDIR)$(pkgdatadir)/xtests
+	for file in $(EXTRA_DIST) ; do \
+		$(INSTALL) $$file $(DESTDIR)$(pkgdatadir)/xtests ; \
+	done
+	for file in $(XTESTS); do \
+		$(INSTALL) .libs/$$file $(DESTDIR)$(pkgdatadir)/xtests ; \
+	done
+
+.PHONY: all install_xtests
